Move bulk of webhook logic to plugin (#4866)

* Move bulk of webhook logic to plugin

* Re-enable cleanup task

* cron tasks

plugins/webhooks/server/.babelrc

@@ -0,0 +1,3 @@
+{ 
+  "extends": "../../../server/.babelrc"
+}

plugins/webhooks/server/api/webhookSubscriptions.ts

@@ -0,0 +1,161 @@
+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 pagination from "@server/routes/api/middlewares/pagination";
+import { WebhookSubscriptionEvent, APIContext } from "@server/types";
+import { assertArray, assertPresent, assertUuid } from "@server/validation";
+import presentWebhookSubscription from "../presenters/webhookSubscription";
+
+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;

plugins/webhooks/server/presenters/webhook.ts

@@ -0,0 +1,38 @@
+import { WebhookDelivery } from "@server/models";
+import { Event } from "@server/types";
+
+export interface WebhookPayload {
+  model: Record<string, unknown> | null;
+  id: string;
+  [key: string]: unknown;
+}
+
+interface WebhookProps {
+  event: Event;
+  delivery: WebhookDelivery;
+  payload: WebhookPayload;
+}
+
+export interface WebhookPresentation {
+  id: string;
+  actorId: string;
+  webhookSubscriptionId: string;
+  event: string;
+  payload: WebhookPayload;
+  createdAt: Date;
+}
+
+export default function presentWebhook({
+  event,
+  delivery,
+  payload,
+}: WebhookProps): WebhookPresentation {
+  return {
+    id: delivery.id,
+    actorId: event.actorId,
+    webhookSubscriptionId: delivery.webhookSubscriptionId,
+    createdAt: delivery.createdAt,
+    event: event.name,
+    payload,
+  };
+}

plugins/webhooks/server/presenters/webhookSubscription.ts

@@ -0,0 +1,16 @@
+import { WebhookSubscription } from "@server/models";
+
+export default function presentWebhookSubscription(
+  webhook: WebhookSubscription
+) {
+  return {
+    id: webhook.id,
+    name: webhook.name,
+    url: webhook.url,
+    secret: webhook.secret,
+    events: webhook.events,
+    enabled: webhook.enabled,
+    createdAt: webhook.createdAt,
+    updatedAt: webhook.updatedAt,
+  };
+}

plugins/webhooks/server/processors/WebhookProcessor.test.ts

@@ -0,0 +1,96 @@
+import { buildUser, buildWebhookSubscription } from "@server/test/factories";
+import { setupTestDatabase } from "@server/test/support";
+import { UserEvent } from "@server/types";
+import DeliverWebhookTask from "../tasks/DeliverWebhookTask";
+import WebhookProcessor from "./WebhookProcessor";
+
+jest.mock("@server/queues/tasks/DeliverWebhookTask");
+const ip = "127.0.0.1";
+
+setupTestDatabase();
+
+beforeEach(async () => {
+  jest.resetAllMocks();
+});
+
+describe("WebhookProcessor", () => {
+  test("it schedules a delivery for the event", async () => {
+    const subscription = await buildWebhookSubscription({
+      url: "http://example.com",
+      events: ["*"],
+    });
+    const signedInUser = await buildUser({ teamId: subscription.teamId });
+    const processor = new WebhookProcessor();
+
+    const event: UserEvent = {
+      name: "users.signin",
+      userId: signedInUser.id,
+      teamId: subscription.teamId,
+      actorId: signedInUser.id,
+      ip,
+    };
+
+    await processor.perform(event);
+
+    expect(DeliverWebhookTask.schedule).toHaveBeenCalled();
+    expect(DeliverWebhookTask.schedule).toHaveBeenCalledWith({
+      event,
+      subscriptionId: subscription.id,
+    });
+  });
+
+  test("not schedule a delivery when not subscribed to event", async () => {
+    const subscription = await buildWebhookSubscription({
+      url: "http://example.com",
+      events: ["users.create"],
+    });
+    const signedInUser = await buildUser({ teamId: subscription.teamId });
+    const processor = new WebhookProcessor();
+    const event: UserEvent = {
+      name: "users.signin",
+      userId: signedInUser.id,
+      teamId: subscription.teamId,
+      actorId: signedInUser.id,
+      ip,
+    };
+
+    await processor.perform(event);
+
+    expect(DeliverWebhookTask.schedule).toHaveBeenCalledTimes(0);
+  });
+
+  test("it schedules a delivery for the event for each subscription", async () => {
+    const subscription = await buildWebhookSubscription({
+      url: "http://example.com",
+      events: ["*"],
+    });
+    const subscriptionTwo = await buildWebhookSubscription({
+      url: "http://example.com",
+      teamId: subscription.teamId,
+      events: ["*"],
+    });
+    const signedInUser = await buildUser({ teamId: subscription.teamId });
+    const processor = new WebhookProcessor();
+
+    const event: UserEvent = {
+      name: "users.signin",
+      userId: signedInUser.id,
+      teamId: subscription.teamId,
+      actorId: signedInUser.id,
+      ip,
+    };
+
+    await processor.perform(event);
+
+    expect(DeliverWebhookTask.schedule).toHaveBeenCalled();
+    expect(DeliverWebhookTask.schedule).toHaveBeenCalledTimes(2);
+    expect(DeliverWebhookTask.schedule).toHaveBeenCalledWith({
+      event,
+      subscriptionId: subscription.id,
+    });
+    expect(DeliverWebhookTask.schedule).toHaveBeenCalledWith({
+      event,
+      subscriptionId: subscriptionTwo.id,
+    });
+  });
+});

plugins/webhooks/server/processors/WebhookProcessor.ts

@@ -0,0 +1,31 @@
+import { WebhookSubscription } from "@server/models";
+import BaseProcessor from "@server/queues/processors/BaseProcessor";
+import { Event } from "@server/types";
+import DeliverWebhookTask from "../tasks/DeliverWebhookTask";
+
+export default class WebhookProcessor extends BaseProcessor {
+  static applicableEvents: ["*"] = ["*"];
+
+  async perform(event: Event) {
+    if (!event.teamId) {
+      return;
+    }
+
+    const webhookSubscriptions = await WebhookSubscription.findAll({
+      where: {
+        enabled: true,
+        teamId: event.teamId,
+      },
+    });
+
+    const applicableSubscriptions = webhookSubscriptions.filter((webhook) =>
+      webhook.validForEvent(event)
+    );
+
+    await Promise.all(
+      applicableSubscriptions.map((subscription) =>
+        DeliverWebhookTask.schedule({ event, subscriptionId: subscription.id })
+      )
+    );
+  }
+}

plugins/webhooks/server/tasks/CleanupWebhookDeliveriesTask.test.ts

@@ -0,0 +1,33 @@
+import { subDays } from "date-fns";
+import { WebhookDelivery } from "@server/models";
+import { buildWebhookDelivery } from "@server/test/factories";
+import { setupTestDatabase } from "@server/test/support";
+import CleanupWebhookDeliveriesTask from "./CleanupWebhookDeliveriesTask";
+
+setupTestDatabase();
+
+const deliveryExists = async (delivery: WebhookDelivery) => {
+  const results = await WebhookDelivery.findOne({ where: { id: delivery.id } });
+  return !!results;
+};
+
+describe("CleanupWebookDeliveriesTask", () => {
+  it("should delete Webhook Deliveries older than 1 week", async () => {
+    const brandNewWebhookDelivery = await buildWebhookDelivery({
+      createdAt: new Date(),
+    });
+    const newishWebhookDelivery = await buildWebhookDelivery({
+      createdAt: subDays(new Date(), 5),
+    });
+    const oldWebhookDelivery = await buildWebhookDelivery({
+      createdAt: subDays(new Date(), 8),
+    });
+
+    const task = new CleanupWebhookDeliveriesTask();
+    await task.perform();
+
+    expect(await deliveryExists(brandNewWebhookDelivery)).toBe(true);
+    expect(await deliveryExists(newishWebhookDelivery)).toBe(true);
+    expect(await deliveryExists(oldWebhookDelivery)).toBe(false);
+  });
+});

plugins/webhooks/server/tasks/CleanupWebhookDeliveriesTask.ts

@@ -0,0 +1,33 @@
+import { subDays } from "date-fns";
+import { Op } from "sequelize";
+import Logger from "@server/logging/Logger";
+import { WebhookDelivery } from "@server/models";
+import BaseTask, {
+  TaskPriority,
+  TaskSchedule,
+} from "@server/queues/tasks/BaseTask";
+
+type Props = void;
+
+export default class CleanupWebhookDeliveriesTask extends BaseTask<Props> {
+  static cron = TaskSchedule.Daily;
+
+  public async perform(_: Props) {
+    Logger.info("task", `Deleting WebhookDeliveries older than one week…`);
+    const count = await WebhookDelivery.unscoped().destroy({
+      where: {
+        createdAt: {
+          [Op.lt]: subDays(new Date(), 7),
+        },
+      },
+    });
+    Logger.info("task", `${count} old WebhookDeliveries deleted.`);
+  }
+
+  public get options() {
+    return {
+      attempts: 1,
+      priority: TaskPriority.Background,
+    };
+  }
+}

plugins/webhooks/server/tasks/DeliverWebhookTask.test.ts

@@ -0,0 +1,229 @@
+import fetchMock from "jest-fetch-mock";
+import { v4 as uuidv4 } from "uuid";
+import { WebhookDelivery } from "@server/models";
+import {
+  buildUser,
+  buildWebhookDelivery,
+  buildWebhookSubscription,
+} from "@server/test/factories";
+import { setupTestDatabase } from "@server/test/support";
+import { UserEvent } from "@server/types";
+import DeliverWebhookTask from "./DeliverWebhookTask";
+
+setupTestDatabase();
+
+beforeEach(async () => {
+  jest.resetAllMocks();
+  fetchMock.resetMocks();
+  fetchMock.doMock();
+});
+
+const ip = "127.0.0.1";
+
+describe("DeliverWebhookTask", () => {
+  test("should hit the subscription url and record a delivery", async () => {
+    const subscription = await buildWebhookSubscription({
+      url: "http://example.com",
+      events: ["*"],
+    });
+    const signedInUser = await buildUser({ teamId: subscription.teamId });
+    const processor = new DeliverWebhookTask();
+
+    fetchMock.mockResponse("SUCCESS", { status: 200 });
+
+    const event: UserEvent = {
+      name: "users.signin",
+      userId: signedInUser.id,
+      teamId: subscription.teamId,
+      actorId: signedInUser.id,
+      ip,
+    };
+    await processor.perform({
+      subscriptionId: subscription.id,
+      event,
+    });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(
+      "http://example.com",
+      expect.anything()
+    );
+    const parsedBody = JSON.parse(
+      fetchMock.mock.calls[0]![1]!.body!.toString()
+    );
+    expect(parsedBody.webhookSubscriptionId).toBe(subscription.id);
+    expect(parsedBody.event).toBe("users.signin");
+    expect(parsedBody.payload.id).toBe(signedInUser.id);
+    expect(parsedBody.payload.model).toBeDefined();
+
+    const deliveries = await WebhookDelivery.findAll({
+      where: { webhookSubscriptionId: subscription.id },
+    });
+    expect(deliveries.length).toBe(1);
+
+    const delivery = deliveries[0];
+    expect(delivery.status).toBe("success");
+    expect(delivery.statusCode).toBe(200);
+    expect(delivery.responseBody).toEqual("SUCCESS");
+  });
+
+  test("should hit the subscription url with signature header", async () => {
+    const subscription = await buildWebhookSubscription({
+      url: "http://example.com",
+      events: ["*"],
+      secret: "secret",
+    });
+    const signedInUser = await buildUser({ teamId: subscription.teamId });
+    const processor = new DeliverWebhookTask();
+
+    const event: UserEvent = {
+      name: "users.signin",
+      userId: signedInUser.id,
+      teamId: subscription.teamId,
+      actorId: signedInUser.id,
+      ip,
+    };
+    await processor.perform({
+      subscriptionId: subscription.id,
+      event,
+    });
+
+    const headers = fetchMock.mock.calls[0]![1]!.headers!;
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(headers["Outline-Signature"]).toMatch(/^t=[0-9]+,s=[a-z0-9]+$/);
+  });
+
+  test("should hit the subscription url when the eventing model doesn't exist", async () => {
+    const subscription = await buildWebhookSubscription({
+      url: "http://example.com",
+      events: ["*"],
+    });
+    const deletedUserId = uuidv4();
+    const signedInUser = await buildUser({ teamId: subscription.teamId });
+
+    const task = new DeliverWebhookTask();
+    const event: UserEvent = {
+      name: "users.delete",
+      userId: deletedUserId,
+      teamId: subscription.teamId,
+      actorId: signedInUser.id,
+      ip,
+    };
+
+    await task.perform({
+      event,
+      subscriptionId: subscription.id,
+    });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(
+      "http://example.com",
+      expect.anything()
+    );
+    const parsedBody = JSON.parse(
+      fetchMock.mock.calls[0]![1]!.body!.toString()
+    );
+    expect(parsedBody.webhookSubscriptionId).toBe(subscription.id);
+    expect(parsedBody.event).toBe("users.delete");
+    expect(parsedBody.payload.id).toBe(deletedUserId);
+
+    const deliveries = await WebhookDelivery.findAll({
+      where: { webhookSubscriptionId: subscription.id },
+    });
+    expect(deliveries.length).toBe(1);
+
+    const delivery = deliveries[0];
+    expect(delivery.status).toBe("success");
+    expect(delivery.statusCode).toBe(200);
+    expect(delivery.responseBody).toBeDefined();
+  });
+
+  test("should mark delivery as failed if post fails", async () => {
+    const subscription = await buildWebhookSubscription({
+      url: "http://example.com",
+      events: ["*"],
+    });
+
+    fetchMock.mockResponse("FAILED", { status: 500 });
+
+    const signedInUser = await buildUser({ teamId: subscription.teamId });
+    const task = new DeliverWebhookTask();
+
+    const event: UserEvent = {
+      name: "users.signin",
+      userId: signedInUser.id,
+      teamId: subscription.teamId,
+      actorId: signedInUser.id,
+      ip,
+    };
+
+    await task.perform({
+      event,
+      subscriptionId: subscription.id,
+    });
+
+    await subscription.reload();
+
+    expect(subscription.enabled).toBe(true);
+
+    const deliveries = await WebhookDelivery.findAll({
+      where: { webhookSubscriptionId: subscription.id },
+    });
+    expect(deliveries.length).toBe(1);
+
+    const delivery = deliveries[0];
+    expect(delivery.status).toBe("failed");
+    expect(delivery.statusCode).toBe(500);
+    expect(delivery.responseBody).toBeDefined();
+    expect(delivery.responseBody).toEqual("FAILED");
+  });
+
+  test("should disable the subscription if past deliveries failed", async () => {
+    const subscription = await buildWebhookSubscription({
+      url: "http://example.com",
+      events: ["*"],
+    });
+    for (let i = 0; i < 25; i++) {
+      await buildWebhookDelivery({
+        webhookSubscriptionId: subscription.id,
+        status: "failed",
+      });
+    }
+
+    fetchMock.mockResponse(JSON.stringify({ message: "Failure" }), {
+      status: 500,
+    });
+
+    const signedInUser = await buildUser({ teamId: subscription.teamId });
+    const task = new DeliverWebhookTask();
+
+    const event: UserEvent = {
+      name: "users.signin",
+      userId: signedInUser.id,
+      teamId: subscription.teamId,
+      actorId: signedInUser.id,
+      ip,
+    };
+
+    await task.perform({
+      event,
+      subscriptionId: subscription.id,
+    });
+
+    await subscription.reload();
+
+    expect(subscription.enabled).toBe(false);
+
+    const deliveries = await WebhookDelivery.findAll({
+      where: { webhookSubscriptionId: subscription.id },
+      order: [["createdAt", "DESC"]],
+    });
+    expect(deliveries.length).toBe(26);
+
+    const delivery = deliveries[0];
+    expect(delivery.status).toBe("failed");
+    expect(delivery.statusCode).toBe(500);
+    expect(delivery.responseBody).toEqual('{"message":"Failure"}');
+  });
+});

plugins/webhooks/server/tasks/DeliverWebhookTask.ts

@@ -0,0 +1,633 @@
+import fetch from "fetch-with-proxy";
+import { useAgent } from "request-filtering-agent";
+import { Op } from "sequelize";
+import WebhookDisabledEmail from "@server/emails/templates/WebhookDisabledEmail";
+import env from "@server/env";
+import Logger from "@server/logging/Logger";
+import {
+  Collection,
+  FileOperation,
+  Group,
+  Integration,
+  Pin,
+  Star,
+  Team,
+  WebhookDelivery,
+  WebhookSubscription,
+  Document,
+  User,
+  Revision,
+  View,
+  Share,
+  CollectionUser,
+  CollectionGroup,
+  GroupUser,
+} from "@server/models";
+import {
+  presentCollection,
+  presentDocument,
+  presentRevision,
+  presentFileOperation,
+  presentGroup,
+  presentIntegration,
+  presentPin,
+  presentStar,
+  presentTeam,
+  presentUser,
+  presentView,
+  presentShare,
+  presentMembership,
+  presentGroupMembership,
+  presentCollectionGroupMembership,
+} from "@server/presenters";
+import BaseTask from "@server/queues/tasks/BaseTask";
+import {
+  CollectionEvent,
+  CollectionGroupEvent,
+  CollectionUserEvent,
+  DocumentEvent,
+  Event,
+  FileOperationEvent,
+  GroupEvent,
+  GroupUserEvent,
+  IntegrationEvent,
+  PinEvent,
+  RevisionEvent,
+  ShareEvent,
+  StarEvent,
+  TeamEvent,
+  UserEvent,
+  ViewEvent,
+  WebhookSubscriptionEvent,
+} from "@server/types";
+import presentWebhook, { WebhookPayload } from "../presenters/webhook";
+import presentWebhookSubscription from "../presenters/webhookSubscription";
+
+function assertUnreachable(event: never) {
+  Logger.warn(`DeliverWebhookTask did not handle ${(event as any).name}`);
+}
+
+type Props = {
+  subscriptionId: string;
+  event: Event;
+};
+
+export default class DeliverWebhookTask extends BaseTask<Props> {
+  public async perform({ subscriptionId, event }: Props) {
+    const subscription = await WebhookSubscription.findByPk(subscriptionId, {
+      rejectOnEmpty: true,
+    });
+
+    if (!subscription.enabled) {
+      Logger.info("task", `WebhookSubscription was disabled before delivery`, {
+        event: event.name,
+        subscriptionId: subscription.id,
+      });
+      return;
+    }
+
+    Logger.info("task", `DeliverWebhookTask: ${event.name}`, {
+      event: event.name,
+      subscriptionId: subscription.id,
+    });
+
+    switch (event.name) {
+      case "api_keys.create":
+      case "api_keys.delete":
+      case "attachments.create":
+      case "attachments.delete":
+      case "subscriptions.create":
+      case "subscriptions.delete":
+      case "authenticationProviders.update":
+        // Ignored
+        return;
+      case "users.create":
+      case "users.signin":
+      case "users.signout":
+      case "users.update":
+      case "users.suspend":
+      case "users.activate":
+      case "users.delete":
+      case "users.invite":
+      case "users.promote":
+      case "users.demote":
+        await this.handleUserEvent(subscription, event);
+        return;
+      case "documents.create":
+      case "documents.publish":
+      case "documents.unpublish":
+      case "documents.delete":
+      case "documents.permanent_delete":
+      case "documents.archive":
+      case "documents.unarchive":
+      case "documents.restore":
+      case "documents.move":
+      case "documents.update":
+      case "documents.title_change":
+        await this.handleDocumentEvent(subscription, event);
+        return;
+      case "documents.update.delayed":
+      case "documents.update.debounced":
+        // Ignored
+        return;
+      case "revisions.create":
+        await this.handleRevisionEvent(subscription, event);
+        return;
+      case "fileOperations.create":
+      case "fileOperations.update":
+      case "fileOperations.delete":
+        await this.handleFileOperationEvent(subscription, event);
+        return;
+      case "collections.create":
+      case "collections.update":
+      case "collections.delete":
+      case "collections.move":
+      case "collections.permission_changed":
+        await this.handleCollectionEvent(subscription, event);
+        return;
+      case "collections.add_user":
+      case "collections.remove_user":
+        await this.handleCollectionUserEvent(subscription, event);
+        return;
+      case "collections.add_group":
+      case "collections.remove_group":
+        await this.handleCollectionGroupEvent(subscription, event);
+        return;
+      case "groups.create":
+      case "groups.update":
+      case "groups.delete":
+        await this.handleGroupEvent(subscription, event);
+        return;
+      case "groups.add_user":
+      case "groups.remove_user":
+        await this.handleGroupUserEvent(subscription, event);
+        return;
+      case "integrations.create":
+      case "integrations.update":
+        await this.handleIntegrationEvent(subscription, event);
+        return;
+      case "teams.create":
+        // Ignored
+        return;
+      case "teams.update":
+        await this.handleTeamEvent(subscription, event);
+        return;
+      case "pins.create":
+      case "pins.update":
+      case "pins.delete":
+        await this.handlePinEvent(subscription, event);
+        return;
+      case "stars.create":
+      case "stars.update":
+      case "stars.delete":
+        await this.handleStarEvent(subscription, event);
+        return;
+      case "shares.create":
+      case "shares.update":
+      case "shares.revoke":
+        await this.handleShareEvent(subscription, event);
+        return;
+      case "webhookSubscriptions.create":
+      case "webhookSubscriptions.delete":
+      case "webhookSubscriptions.update":
+        await this.handleWebhookSubscriptionEvent(subscription, event);
+        return;
+      case "views.create":
+        await this.handleViewEvent(subscription, event);
+        return;
+      default:
+        assertUnreachable(event);
+    }
+  }
+
+  private async handleWebhookSubscriptionEvent(
+    subscription: WebhookSubscription,
+    event: WebhookSubscriptionEvent
+  ): Promise<void> {
+    const model = await WebhookSubscription.findByPk(event.modelId, {
+      paranoid: false,
+    });
+
+    let data = null;
+    if (model) {
+      data = {
+        ...presentWebhookSubscription(model),
+        secret: undefined,
+      };
+    }
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.modelId,
+        model: data,
+      },
+    });
+  }
+
+  private async handleViewEvent(
+    subscription: WebhookSubscription,
+    event: ViewEvent
+  ): Promise<void> {
+    const model = await View.scope("withUser").findByPk(event.modelId, {
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.modelId,
+        model: model && presentView(model),
+      },
+    });
+  }
+
+  private async handleStarEvent(
+    subscription: WebhookSubscription,
+    event: StarEvent
+  ): Promise<void> {
+    const model = await Star.findByPk(event.modelId, {
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.modelId,
+        model: model && presentStar(model),
+      },
+    });
+  }
+
+  private async handleShareEvent(
+    subscription: WebhookSubscription,
+    event: ShareEvent
+  ): Promise<void> {
+    const model = await Share.findByPk(event.modelId, {
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.modelId,
+        model: model && presentShare(model),
+      },
+    });
+  }
+
+  private async handlePinEvent(
+    subscription: WebhookSubscription,
+    event: PinEvent
+  ): Promise<void> {
+    const model = await Pin.findByPk(event.modelId, {
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.modelId,
+        model: model && presentPin(model),
+      },
+    });
+  }
+
+  private async handleTeamEvent(
+    subscription: WebhookSubscription,
+    event: TeamEvent
+  ): Promise<void> {
+    const model = await Team.scope("withDomains").findByPk(event.teamId, {
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.teamId,
+        model: model && presentTeam(model),
+      },
+    });
+  }
+
+  private async handleIntegrationEvent(
+    subscription: WebhookSubscription,
+    event: IntegrationEvent
+  ): Promise<void> {
+    const model = await Integration.findByPk(event.modelId, {
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.modelId,
+        model: model && presentIntegration(model),
+      },
+    });
+  }
+
+  private async handleGroupEvent(
+    subscription: WebhookSubscription,
+    event: GroupEvent
+  ): Promise<void> {
+    const model = await Group.findByPk(event.modelId, {
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.modelId,
+        model: model && presentGroup(model),
+      },
+    });
+  }
+
+  private async handleGroupUserEvent(
+    subscription: WebhookSubscription,
+    event: GroupUserEvent
+  ): Promise<void> {
+    const model = await GroupUser.scope(["withUser", "withGroup"]).findOne({
+      where: {
+        groupId: event.modelId,
+        userId: event.userId,
+      },
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: `${event.userId}-${event.modelId}`,
+        model: model && presentGroupMembership(model),
+        group: model && presentGroup(model.group),
+        user: model && presentUser(model.user),
+      },
+    });
+  }
+
+  private async handleCollectionEvent(
+    subscription: WebhookSubscription,
+    event: CollectionEvent
+  ): Promise<void> {
+    const model = await Collection.findByPk(event.collectionId, {
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.collectionId,
+        model: model && presentCollection(model),
+      },
+    });
+  }
+
+  private async handleCollectionUserEvent(
+    subscription: WebhookSubscription,
+    event: CollectionUserEvent
+  ): Promise<void> {
+    const model = await CollectionUser.scope([
+      "withUser",
+      "withCollection",
+    ]).findOne({
+      where: {
+        collectionId: event.collectionId,
+        userId: event.userId,
+      },
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: `${event.userId}-${event.collectionId}`,
+        model: model && presentMembership(model),
+        collection: model && presentCollection(model.collection),
+        user: model && presentUser(model.user),
+      },
+    });
+  }
+
+  private async handleCollectionGroupEvent(
+    subscription: WebhookSubscription,
+    event: CollectionGroupEvent
+  ): Promise<void> {
+    const model = await CollectionGroup.scope([
+      "withGroup",
+      "withCollection",
+    ]).findOne({
+      where: {
+        collectionId: event.collectionId,
+        groupId: event.modelId,
+      },
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: `${event.modelId}-${event.collectionId}`,
+        model: model && presentCollectionGroupMembership(model),
+        collection: model && presentCollection(model.collection),
+        group: model && presentGroup(model.group),
+      },
+    });
+  }
+
+  private async handleFileOperationEvent(
+    subscription: WebhookSubscription,
+    event: FileOperationEvent
+  ): Promise<void> {
+    const model = await FileOperation.findByPk(event.modelId, {
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.modelId,
+        model: model && presentFileOperation(model),
+      },
+    });
+  }
+
+  private async handleDocumentEvent(
+    subscription: WebhookSubscription,
+    event: DocumentEvent
+  ): Promise<void> {
+    const model = await Document.findByPk(event.documentId, {
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.documentId,
+        model: model && (await presentDocument(model)),
+      },
+    });
+  }
+
+  private async handleRevisionEvent(
+    subscription: WebhookSubscription,
+    event: RevisionEvent
+  ): Promise<void> {
+    const model = await Revision.findByPk(event.modelId, {
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.modelId,
+        model: model && (await presentRevision(model)),
+      },
+    });
+  }
+
+  private async handleUserEvent(
+    subscription: WebhookSubscription,
+    event: UserEvent
+  ): Promise<void> {
+    const model = await User.findByPk(event.userId, {
+      paranoid: false,
+    });
+
+    await this.sendWebhook({
+      event,
+      subscription,
+      payload: {
+        id: event.userId,
+        model: model && presentUser(model),
+      },
+    });
+  }
+
+  private async sendWebhook({
+    event,
+    subscription,
+    payload,
+  }: {
+    event: Event;
+    subscription: WebhookSubscription;
+    payload: WebhookPayload;
+  }) {
+    const delivery = await WebhookDelivery.create({
+      webhookSubscriptionId: subscription.id,
+      status: "pending",
+    });
+
+    let response, requestBody, requestHeaders, status;
+    try {
+      requestBody = presentWebhook({
+        event,
+        delivery,
+        payload,
+      });
+      requestHeaders = {
+        "Content-Type": "application/json",
+        "user-agent": `Outline-Webhooks${
+          env.VERSION ? `/${env.VERSION.slice(0, 7)}` : ""
+        }`,
+      };
+
+      const signature = subscription.signature(JSON.stringify(requestBody));
+      if (signature) {
+        requestHeaders["Outline-Signature"] = signature;
+      }
+
+      response = await fetch(subscription.url, {
+        method: "POST",
+        headers: requestHeaders,
+        body: JSON.stringify(requestBody),
+        redirect: "error",
+        timeout: 5000,
+        agent: useAgent(subscription.url),
+      });
+      status = response.ok ? "success" : "failed";
+    } catch (err) {
+      Logger.error("Failed to send webhook", err, {
+        event,
+        deliveryId: delivery.id,
+      });
+      status = "failed";
+    }
+
+    await delivery.update({
+      status,
+      statusCode: response ? response.status : null,
+      requestBody,
+      requestHeaders,
+      responseBody: response ? await response.text() : "",
+      responseHeaders: response
+        ? Object.fromEntries(response.headers.entries())
+        : {},
+    });
+
+    if (status === "failed") {
+      try {
+        await this.checkAndDisableSubscription(subscription);
+      } catch (err) {
+        Logger.error("Failed to check and disable recent deliveries", err, {
+          event,
+          deliveryId: delivery.id,
+        });
+      }
+    }
+  }
+
+  private async checkAndDisableSubscription(subscription: WebhookSubscription) {
+    const recentDeliveries = await WebhookDelivery.findAll({
+      where: {
+        webhookSubscriptionId: subscription.id,
+      },
+      order: [["createdAt", "DESC"]],
+      limit: 25,
+    });
+
+    const allFailed = recentDeliveries.every(
+      (delivery) => delivery.status === "failed"
+    );
+
+    if (recentDeliveries.length === 25 && allFailed) {
+      // If the last 25 deliveries failed, disable the subscription
+      await subscription.disable();
+
+      // Send an email to the creator of the webhook to let them know
+      const [createdBy, team] = await Promise.all([
+        User.findOne({
+          where: {
+            id: subscription.createdById,
+            suspendedAt: { [Op.is]: null },
+          },
+        }),
+        subscription.$get("team"),
+      ]);
+
+      if (createdBy && team) {
+        await WebhookDisabledEmail.schedule({
+          to: createdBy.email,
+          teamUrl: team.url,
+          webhookName: subscription.name,
+        });
+      }
+    }
+  }
+}