feat: Document subscriptions (#3834)

Co-authored-by: Tom Moor <tom.moor@gmail.com>

server/scripts/20220722000000-backfill-subscriptions.test.ts

@@ -0,0 +1,176 @@
+import { Subscription } from "@server/models";
+import { buildDocument, buildUser } from "@server/test/factories";
+import { getTestDatabase } from "@server/test/support";
+import script from "./20220722000000-backfill-subscriptions";
+
+const db = getTestDatabase();
+
+beforeEach(db.flush);
+afterAll(db.disconnect);
+
+describe("#work", () => {
+  it("should create subscriptions and subscriptions for document creator and collaborators", async () => {
+    const admin = await buildUser();
+
+    // 5 collaborators that have cyclically contributed to documents.
+    const collaborator0 = await buildUser({ teamId: admin.teamId });
+    const collaborator1 = await buildUser({ teamId: admin.teamId });
+    const collaborator2 = await buildUser({ teamId: admin.teamId });
+    const collaborator3 = await buildUser({ teamId: admin.teamId });
+    const collaborator4 = await buildUser({ teamId: admin.teamId });
+
+    const document0 = await buildDocument({
+      userId: collaborator0.id,
+      collaboratorIds: [collaborator1.id, collaborator2.id],
+    });
+
+    const document1 = await buildDocument({
+      userId: collaborator1.id,
+      collaboratorIds: [collaborator2.id, collaborator3.id],
+    });
+
+    const document2 = await buildDocument({
+      userId: collaborator2.id,
+      collaboratorIds: [collaborator3.id, collaborator4.id],
+    });
+
+    const document3 = await buildDocument({
+      userId: collaborator3.id,
+      collaboratorIds: [collaborator4.id, collaborator0.id],
+    });
+
+    const document4 = await buildDocument({
+      userId: collaborator4.id,
+      collaboratorIds: [collaborator0.id, collaborator1.id],
+    });
+
+    await script();
+
+    const subscriptions = await Subscription.findAll();
+
+    subscriptions.forEach((subscription) => {
+      expect(subscription.id).toBeDefined();
+      expect(subscription.event).toEqual("documents.update");
+    });
+
+    // 5 documents, 3 collaborators each = 15.
+    expect(subscriptions.length).toEqual(15);
+
+    expect(subscriptions[0].documentId).toEqual(document0.id);
+    expect(subscriptions[1].documentId).toEqual(document0.id);
+    expect(subscriptions[2].documentId).toEqual(document0.id);
+
+    const s0 = [
+      subscriptions[0].userId,
+      subscriptions[1].userId,
+      subscriptions[2].userId,
+    ];
+
+    expect(s0.some((s) => s.includes(collaborator0.id))).toBe(true);
+    expect(s0.some((s) => s.includes(collaborator1.id))).toBe(true);
+    expect(s0.some((s) => s.includes(collaborator2.id))).toBe(true);
+
+    expect(subscriptions[3].documentId).toEqual(document1.id);
+    expect(subscriptions[4].documentId).toEqual(document1.id);
+    expect(subscriptions[5].documentId).toEqual(document1.id);
+
+    const s1 = [
+      subscriptions[3].userId,
+      subscriptions[4].userId,
+      subscriptions[5].userId,
+    ];
+
+    expect(s1.some((s) => s.includes(collaborator1.id))).toBe(true);
+    expect(s1.some((s) => s.includes(collaborator2.id))).toBe(true);
+    expect(s1.some((s) => s.includes(collaborator3.id))).toBe(true);
+
+    expect(subscriptions[6].documentId).toEqual(document2.id);
+    expect(subscriptions[7].documentId).toEqual(document2.id);
+    expect(subscriptions[8].documentId).toEqual(document2.id);
+
+    const s2 = [
+      subscriptions[6].userId,
+      subscriptions[7].userId,
+      subscriptions[8].userId,
+    ];
+
+    expect(s2.some((s) => s.includes(collaborator2.id))).toBe(true);
+    expect(s2.some((s) => s.includes(collaborator3.id))).toBe(true);
+    expect(s2.some((s) => s.includes(collaborator4.id))).toBe(true);
+
+    expect(subscriptions[9].documentId).toEqual(document3.id);
+    expect(subscriptions[10].documentId).toEqual(document3.id);
+    expect(subscriptions[11].documentId).toEqual(document3.id);
+
+    const s3 = [
+      subscriptions[9].userId,
+      subscriptions[10].userId,
+      subscriptions[11].userId,
+    ];
+
+    expect(s3.some((s) => s.includes(collaborator0.id))).toBe(true);
+    expect(s3.some((s) => s.includes(collaborator3.id))).toBe(true);
+    expect(s3.some((s) => s.includes(collaborator4.id))).toBe(true);
+
+    expect(subscriptions[12].documentId).toEqual(document4.id);
+    expect(subscriptions[13].documentId).toEqual(document4.id);
+    expect(subscriptions[14].documentId).toEqual(document4.id);
+
+    const s4 = [
+      subscriptions[12].userId,
+      subscriptions[13].userId,
+      subscriptions[14].userId,
+    ];
+
+    expect(s4.some((s) => s.includes(collaborator0.id))).toBe(true);
+    expect(s4.some((s) => s.includes(collaborator1.id))).toBe(true);
+    expect(s4.some((s) => s.includes(collaborator4.id))).toBe(true);
+  });
+
+  it("should not create subscriptions and subscriptions for non-collaborators", async () => {
+    const admin = await buildUser();
+
+    // 2 collaborators.
+    const collaborator0 = await buildUser({ teamId: admin.teamId });
+    const collaborator1 = await buildUser({ teamId: admin.teamId });
+
+    // 1 viewer from the same team.
+    const viewer = await buildUser({ teamId: admin.teamId });
+
+    const document0 = await buildDocument({
+      userId: collaborator0.id,
+      collaboratorIds: [collaborator1.id],
+    });
+
+    await script();
+
+    const subscriptions = await Subscription.findAll();
+
+    subscriptions.forEach((subscription) => {
+      expect(subscription.id).toBeDefined();
+    });
+
+    expect(
+      subscriptions.filter((subscription) => subscription.userId === viewer.id)
+        .length
+    ).toEqual(0);
+
+    expect(subscriptions[0].documentId).toEqual(document0.id);
+    expect(subscriptions[1].documentId).toEqual(document0.id);
+    expect(subscriptions.map((s) => s.userId)).toContain(collaborator1.id);
+    expect(subscriptions.map((s) => s.userId)).toContain(collaborator0.id);
+    expect(subscriptions[0].event).toEqual("documents.update");
+    expect(subscriptions[1].event).toEqual("documents.update");
+  });
+
+  it("should be idempotent", async () => {
+    await buildDocument();
+
+    await script();
+    await script();
+
+    const count = await Subscription.count();
+
+    expect(count).toEqual(1);
+  });
+});

server/scripts/20220722000000-backfill-subscriptions.ts

@@ -0,0 +1,51 @@
+import "./bootstrap";
+import { Subscription, Document } from "@server/models";
+
+const limit = 100;
+let page = parseInt(process.argv[2], 10);
+page = Number.isNaN(page) ? 0 : page;
+
+export default async function main(exit = false) {
+  const work = async (page: number) => {
+    console.log(`Backfill subscription… page ${page}`);
+
+    // Retrieve all documents within set limit.
+    const documents = await Document.findAll({
+      attributes: ["collaboratorIds", "id"],
+      limit,
+      offset: page * limit,
+      order: [["createdAt", "ASC"]],
+    });
+
+    for (const document of documents) {
+      try {
+        await Promise.all(
+          document.collaboratorIds.map((collaboratorId) =>
+            Subscription.findOrCreate({
+              where: {
+                userId: collaboratorId,
+                documentId: document.id,
+                event: "documents.update",
+              },
+            })
+          )
+        );
+      } catch (err) {
+        console.error(`Failed at ${document.id}:`, err);
+
+        continue;
+      }
+    }
+  };
+
+  await work(page);
+
+  if (exit) {
+    console.log("Backfill complete");
+    process.exit(0);
+  }
+}
+
+if (process.env.NODE_ENV !== "test") {
+  main(true);
+}

server/scripts/bootstrap.ts

@@ -5,7 +5,6 @@ if (process.env.NODE_ENV !== "test") {
   });
 }
 
-// @ts-expect-error ts-migrate(2322) FIXME: Type 'true' is not assignable to type 'string | un... Remove this comment to see the full error message
-process.env.SINGLE_RUN = true;
+require("../database/sequelize");
 
 export {};