Update lint.yml

.github/workflows/lint.yml

@@ -6,7 +6,7 @@ on:
 
 jobs:
   run-linters:
-    if: startsWith(github.actor, 'codegen-sh')
+    if:  startsWith(github.head_ref, 'codegen-')
     name: Run linters
     runs-on: ubuntu-latest
 

app/components/Avatar/AvatarWithPresence.tsx

@@ -7,43 +7,17 @@ import User from "~/models/User";
 import Tooltip from "~/components/Tooltip";
 import Avatar, { AvatarSize } from "./Avatar";
 
-/**
- * Props for the AvatarWithPresence component
- */
 type Props = {
-  /** The user to display the avatar for */
   user: User;
-  /** Whether the user is currently present in the document */
   isPresent: boolean;
-  /** Whether the user is currently editing the document */
   isEditing: boolean;
-  /** Whether the user is currently observing the document */
   isObserving: boolean;
-  /** Whether this avatar represents the current user */
   isCurrentUser: boolean;
-  /** Optional click handler for the avatar */
   onClick?: React.MouseEventHandler<HTMLImageElement>;
-  /** Size of the avatar, defaults to AvatarSize.Large */
   size?: AvatarSize;
-  /** Optional inline styles to apply to the avatar wrapper */
   style?: React.CSSProperties;
 };
 
-/**
- * AvatarWithPresence component displays a user's avatar with visual indicators
- * for their current status (present, editing, observing).
- *
- * The component shows different visual states:
- * - Present users have full opacity
- * - Non-present users have reduced opacity
- * - Observing users have a colored border matching their user color
- * - Hovering shows a colored border
- *
- * A tooltip displays the user's name and current status.
- *
- * @param props - Component properties
- * @returns React component
- */
 function AvatarWithPresence({
   onClick,
   user,
@@ -90,33 +64,16 @@ function AvatarWithPresence({
   );
 }
 
-/**
- * Centered container for tooltip content
- */
 const Centered = styled.div`
   text-align: center;
 `;
 
-/**
- * Props for the AvatarPresence styled component
- */
 type AvatarWrapperProps = {
-  /** Whether the user is currently present */
   $isPresent: boolean;
-  /** Whether the user is currently observing */
   $isObserving: boolean;
-  /** The user's color for border highlighting */
   $color: string;
 };
 
-/**
- * Styled component that wraps the Avatar and provides visual indicators
- * for the user's presence status.
- *
- * - Adjusts opacity based on presence
- * - Adds colored borders for observing users
- * - Handles hover effects
- */
 const AvatarPresence = styled.div<AvatarWrapperProps>`
   opacity: ${(props) => (props.$isPresent ? 1 : 0.5)};
   transition: opacity 250ms ease-in-out;

app/editor/components/SuggestionsMenu.tsx

@@ -645,11 +645,12 @@ function SuggestionsMenu<T extends MenuItem>(props: Props<T>) {
                     "section" in item ? item.section?.({ t }) : undefined;
 
                   const response = (
-                    <React.Fragment key={`${index}-${item.name}`}>
+                    <>
                       {currentHeading !== previousHeading && (
                         <Header key={currentHeading}>{currentHeading}</Header>
                       )}
                       <ListItem
+                        key={index}
                         onPointerMove={handlePointerMove}
                         onPointerDown={handlePointerDown}
                       >
@@ -658,7 +659,7 @@ function SuggestionsMenu<T extends MenuItem>(props: Props<T>) {
                           onClick: () => handleClickItem(item),
                         })}
                       </ListItem>
-                    </React.Fragment>
+                    </>
                   );
 
                   previousHeading = currentHeading;

app/hooks/useDictionary.ts

@@ -1,11 +1,6 @@
 import * as React from "react";
 import { useTranslation } from "react-i18next";
 
-/**
- * Hook that provides a dictionary of translated UI strings.
- *
- * @returns An object containing all translated UI strings used throughout the application
- */
 export default function useDictionary() {
   const { t } = useTranslation();
 

app/hooks/useMaxHeight.ts

@@ -1,15 +1,6 @@
 import * as React from "react";
 import useWindowSize from "./useWindowSize";
 
-/**
- * Hook to calculate the maximum height for an element based on its position and viewport size.
- *
- * @param options Configuration options
- * @param options.elementRef A ref pointing to the element to calculate max height for
- * @param options.maxViewportPercentage The maximum height of the element as a percentage of the viewport
- * @param options.margin The margin to apply to the positioning
- * @returns Object containing the calculated maxHeight and a function to recalculate it
- */
 const useMaxHeight = ({
   elementRef,
   maxViewportPercentage = 90,

app/hooks/useMediaQuery.ts

@@ -1,11 +1,5 @@
 import { useState, useEffect } from "react";
 
-/**
- * Hook to check if a media query matches the current viewport.
- *
- * @param query The CSS media query to check against
- * @returns boolean indicating whether the media query matches
- */
 export default function useMediaQuery(query: string): boolean {
   const [matches, setMatches] = useState<boolean>(false);
 

app/hooks/useMobile.ts

@@ -1,11 +1,6 @@
 import { breakpoints } from "@shared/styles";
 import useMediaQuery from "~/hooks/useMediaQuery";
 
-/**
- * Hook to detect if the current viewport is mobile-sized.
- *
- * @returns boolean indicating whether the current viewport is mobile-sized
- */
 export default function useMobile(): boolean {
   return useMediaQuery(`(max-width: ${breakpoints.tablet - 1}px)`);
 }

app/hooks/useQuery.ts

@@ -1,11 +1,6 @@
 import React from "react";
 import { useLocation } from "react-router-dom";
 
-/**
- * Hook to access URL query parameters from the current location.
- *
- * @returns URLSearchParams object containing the current URL query parameters
- */
 export default function useQuery() {
   const location = useLocation();
 

app/hooks/useStores.ts

@@ -2,11 +2,6 @@ import { MobXProviderContext } from "mobx-react";
 import * as React from "react";
 import RootStore from "~/stores";
 
-/**
- * Hook to access the MobX stores from the React context.
- *
- * @returns The root store containing all application stores
- */
 export default function useStores() {
   return React.useContext(MobXProviderContext) as typeof RootStore;
 }

app/hooks/useUnmount.ts

@@ -1,10 +1,5 @@
 import * as React from "react";
 
-/**
- * Hook that executes a callback when the component unmounts.
- *
- * @param callback Function to be called on component unmount
- */
 const useUnmount = (callback: (...args: Array<any>) => any) => {
   const ref = React.useRef(callback);
   ref.current = callback;

app/hooks/useViewportHeight.ts

@@ -1,11 +1,5 @@
 import { useLayoutEffect, useState } from "react";
 
-/**
- * Hook to get the current viewport height, accounting for mobile virtual keyboards.
- * Uses the VisualViewport API when available, falling back to window.innerHeight.
- *
- * @returns The current viewport height in pixels
- */
 export default function useViewportHeight(): number | void {
   // https://developer.mozilla.org/en-US/docs/Web/API/VisualViewport#browser_compatibility
   // Note: No support in Firefox at time of writing, however this mainly exists

app/hooks/useWindowScrollPosition.ts

@@ -13,13 +13,6 @@ const defaultOptions = {
   throttle: 100,
 };
 
-/**
- * Hook to track the window's scroll position.
- *
- * @param options Configuration options
- * @param options.throttle Time in milliseconds to throttle the scroll event
- * @returns Object containing the current scroll position (x, y coordinates)
- */
 export default function useWindowScrollPosition(options: {
   throttle: number;
 }): {

app/models/Import.ts

@@ -15,9 +15,6 @@ class Import extends Model {
   /** The name of the import. */
   name: string;
 
-  /** Descriptive error message when the import errors out. */
-  error: string | null;
-
   /** The current state of the import. */
   @Field
   @observable

app/scenes/Settings/components/ImportListItem.tsx

@@ -15,7 +15,6 @@ import Time from "~/components/Time";
 import useCurrentUser from "~/hooks/useCurrentUser";
 import useStores from "~/hooks/useStores";
 import { ImportMenu } from "~/menus/ImportMenu";
-import isCloudHosted from "~/utils/isCloudHosted";
 
 type Props = {
   /** Import that's displayed as list item. */
@@ -30,10 +29,6 @@ export const ImportListItem = observer(({ importModel }: Props) => {
   const showProgress =
     importModel.state !== ImportState.Canceled &&
     importModel.state !== ImportState.Errored;
-  const showErrorInfo =
-    !isCloudHosted &&
-    importModel.state === ImportState.Errored &&
-    !!importModel.error;
 
   const stateMap = React.useMemo(
     () => ({
@@ -119,12 +114,6 @@ export const ImportListItem = observer(({ importModel }: Props) => {
       subtitle={
         <>
           {stateMap[importModel.state]}&nbsp;•&nbsp;
-          {showErrorInfo && (
-            <>
-              {importModel.error}
-              {`. ${t("Check server logs for more details.")}`}&nbsp;•&nbsp;
-            </>
-          )}
           {t(`{{userName}} requested`, {
             userName:
               user.id === importModel.createdBy.id

server/migrations/20250327110739-add-error-to-imports.js

@@ -1,37 +0,0 @@
-"use strict";
-
-/** @type {import('sequelize-cli').Migration} */
-module.exports = {
-  async up(queryInterface, Sequelize) {
-    await queryInterface.sequelize.transaction(async transaction => {
-      await queryInterface.addColumn(
-        "imports",
-        "error",
-        {
-          type: Sequelize.STRING,
-          allowNull: true,
-        },
-        { transaction }
-      );
-
-      await queryInterface.addColumn(
-        "import_tasks",
-        "error",
-        {
-          type: Sequelize.STRING,
-          allowNull: true,
-        },
-        { transaction }
-      );
-    });
-  },
-
-  async down(queryInterface, Sequelize) {
-    await queryInterface.sequelize.transaction(async transaction => {
-      await queryInterface.removeColumn("imports", "error", { transaction });
-      await queryInterface.removeColumn("import_tasks", "error", {
-        transaction,
-      });
-    });
-  },
-};

server/models/Import.ts

@@ -60,9 +60,6 @@ class Import<T extends ImportableIntegrationService> extends ParanoidModel<
   @Column(DataType.INTEGER)
   documentCount: number;
 
-  @Column
-  error: string | null;
-
   // associations
 
   @BelongsTo(() => Integration, "integrationId")

server/models/ImportTask.ts

@@ -45,9 +45,6 @@ class ImportTask<T extends ImportableIntegrationService> extends IdModel<
   @Column(DataType.JSONB)
   output: ImportTaskOutput | null;
 
-  @Column
-  error: string | null;
-
   // associations
 
   @BelongsTo(() => Import, "importId")

server/models/helpers/NotificationHelper.test.ts

@@ -9,7 +9,7 @@ import NotificationHelper from "./NotificationHelper";
 
 describe("NotificationHelper", () => {
   describe("getCommentNotificationRecipients", () => {
-    it("should only return users who have notification enabled for comment creation and are subscribed to the document in case of new thread", async () => {
+    it("should return users who have notification enabled for comment creation and are subscribed to the document in case of parent comment", async () => {
       const documentAuthor = await buildUser();
       const document = await buildDocument({
         userId: documentAuthor.id,
@@ -54,7 +54,7 @@ describe("NotificationHelper", () => {
       expect(recipients[0].id).toEqual(notificationEnabledUser.id);
     });
 
-    it("should only return users who have notification enabled for comment creation and are in the thread in case of child comment", async () => {
+    it("should return users who have notification enabled for comment creation and are in the thread in case of child comment", async () => {
       const documentAuthor = await buildUser();
       const document = await buildDocument({
         userId: documentAuthor.id,
@@ -112,104 +112,32 @@ describe("NotificationHelper", () => {
       expect(recipients.length).toEqual(1);
       expect(recipients[0].id).toEqual(notificationEnabledUserInThread.id);
     });
-
-    it("should not return users who have notification disabled for comment creation and are in the thread in case of child comment", async () => {
-      const documentAuthor = await buildUser();
-      const document = await buildDocument({
-        userId: documentAuthor.id,
-        teamId: documentAuthor.teamId,
-      });
-      const notificationEnabledUserInThread = await buildUser({
-        teamId: document.teamId,
-        notificationSettings: { [NotificationEventType.CreateComment]: false },
-      });
-      const notificationEnabledUserNotInThread = await buildUser({
-        teamId: document.teamId,
-        notificationSettings: { [NotificationEventType.CreateComment]: true },
-      });
-      const notificationDisabledUser = await buildUser({
-        teamId: document.teamId,
-        notificationSettings: {
-          [NotificationEventType.CreateComment]: false,
-        },
-      });
-      await Promise.all([
-        buildSubscription({
-          userId: documentAuthor.id,
-          documentId: document.id,
-        }),
-        buildSubscription({
-          userId: notificationEnabledUserInThread.id,
-          documentId: document.id,
-        }),
-        buildSubscription({
-          userId: notificationEnabledUserNotInThread.id,
-          documentId: document.id,
-        }),
-        buildSubscription({
-          userId: notificationDisabledUser.id,
-          documentId: document.id,
-        }),
-      ]);
-      const parentComment = await buildComment({
-        documentId: document.id,
-        userId: notificationEnabledUserInThread.id,
-      });
-      const childComment = await buildComment({
-        documentId: document.id,
-        userId: documentAuthor.id,
-        parentCommentId: parentComment.id,
-      });
-
-      const recipients =
-        await NotificationHelper.getCommentNotificationRecipients(
-          document,
-          childComment,
-          childComment.createdById
-        );
-
-      expect(recipients.length).toEqual(0);
-    });
-
-    it("should return users who have notification enabled and are in the thread but not explicitly subscribed to document", async () => {
-      const documentAuthor = await buildUser();
-      const document = await buildDocument({
-        userId: documentAuthor.id,
-        teamId: documentAuthor.teamId,
-      });
-      const notificationEnabledUserInThread = await buildUser({
-        teamId: document.teamId,
-        notificationSettings: { [NotificationEventType.CreateComment]: true },
-      });
-      await buildUser({
-        teamId: document.teamId,
-        notificationSettings: {
-          [NotificationEventType.CreateComment]: false,
-        },
-      });
-      const parentComment = await buildComment({
-        documentId: document.id,
-        userId: notificationEnabledUserInThread.id,
-      });
-      const childComment = await buildComment({
-        documentId: document.id,
-        userId: documentAuthor.id,
-        parentCommentId: parentComment.id,
-      });
-
-      const recipients =
-        await NotificationHelper.getCommentNotificationRecipients(
-          document,
-          childComment,
-          childComment.createdById
-        );
-
-      expect(recipients.length).toEqual(1);
-      expect(recipients[0].id).toEqual(notificationEnabledUserInThread.id);
-    });
   });
 
   describe("getDocumentNotificationRecipients", () => {
+    it("should return all users who have notification enabled for the event", async () => {
+      const documentAuthor = await buildUser();
+      const document = await buildDocument({
+        userId: documentAuthor.id,
+        teamId: documentAuthor.teamId,
+      });
+      const notificationEnabledUser = await buildUser({
+        teamId: document.teamId,
+        notificationSettings: { [NotificationEventType.UpdateDocument]: true },
+      });
+
+      const recipients =
+        await NotificationHelper.getDocumentNotificationRecipients({
+          document,
+          notificationType: NotificationEventType.UpdateDocument,
+          onlySubscribers: false,
+          actorId: documentAuthor.id,
+        });
+
+      expect(recipients.length).toEqual(1);
+      expect(recipients[0].id).toEqual(notificationEnabledUser.id);
+    });
+
     it("should return users who have subscribed to the document", async () => {
       const documentAuthor = await buildUser();
       const document = await buildDocument({
@@ -222,17 +150,11 @@ describe("NotificationHelper", () => {
         documentId: document.id,
       });
 
-      const deletedUser = await buildUser({ teamId: document.teamId });
-      await buildSubscription({
-        userId: deletedUser.id,
-        documentId: document.id,
-      });
-      await deletedUser.destroy();
-
       const recipients =
         await NotificationHelper.getDocumentNotificationRecipients({
           document,
           notificationType: NotificationEventType.UpdateDocument,
+          onlySubscribers: true,
           actorId: documentAuthor.id,
         });
 
@@ -256,6 +178,7 @@ describe("NotificationHelper", () => {
         await NotificationHelper.getDocumentNotificationRecipients({
           document,
           notificationType: NotificationEventType.UpdateDocument,
+          onlySubscribers: true,
           actorId: documentAuthor.id,
         });
 
@@ -293,6 +216,7 @@ describe("NotificationHelper", () => {
         await NotificationHelper.getDocumentNotificationRecipients({
           document,
           notificationType: NotificationEventType.UpdateDocument,
+          onlySubscribers: true,
           actorId: documentAuthor.id,
         });
 
@@ -311,19 +235,20 @@ describe("NotificationHelper", () => {
       });
       const notificationEnabledUser = await buildUser({
         teamId: document.teamId,
-        notificationSettings: { [NotificationEventType.PublishDocument]: true },
+        notificationSettings: { [NotificationEventType.UpdateDocument]: true },
       });
       // suspended user
       await buildUser({
         suspendedAt: new Date(),
         teamId: document.teamId,
-        notificationSettings: { [NotificationEventType.PublishDocument]: true },
+        notificationSettings: { [NotificationEventType.UpdateDocument]: true },
       });
 
       const recipients =
         await NotificationHelper.getDocumentNotificationRecipients({
           document,
-          notificationType: NotificationEventType.PublishDocument,
+          notificationType: NotificationEventType.UpdateDocument,
+          onlySubscribers: false,
           actorId: documentAuthor.id,
         });
 

server/models/helpers/NotificationHelper.ts

@@ -14,7 +14,7 @@ import {
   Comment,
   View,
 } from "@server/models";
-import { canUserAccessDocument } from "@server/utils/permissions";
+import { can } from "@server/policies";
 import { ProsemirrorHelper } from "./ProsemirrorHelper";
 
 export default class NotificationHelper {
@@ -60,12 +60,18 @@ export default class NotificationHelper {
     comment: Comment,
     actorId: string
   ): Promise<User[]> => {
-    let recipients: User[];
+    let recipients = await this.getDocumentNotificationRecipients({
+      document,
+      notificationType: NotificationEventType.CreateComment,
+      onlySubscribers: !comment.parentCommentId,
+      actorId,
+    });
 
-    // If this is a reply to another comment, we want to notify all users
-    // that are involved in the thread of this comment (i.e. the original
-    // comment and all replies to it).
-    if (comment.parentCommentId) {
+    recipients = recipients.filter((recipient) =>
+      recipient.subscribedToEventType(NotificationEventType.CreateComment)
+    );
+
+    if (recipients.length > 0 && comment.parentCommentId) {
       const contextComments = await Comment.findAll({
         attributes: ["createdById", "data"],
         where: {
@@ -89,37 +95,13 @@ export default class NotificationHelper {
       const userIdsInThread = uniq([
         ...createdUserIdsInThread,
         ...mentionedUserIdsInThread,
-      ]).filter((userId) => userId !== actorId);
-
-      recipients = await User.findAll({
-        where: {
-          id: {
-            [Op.in]: userIdsInThread,
-          },
-          teamId: document.teamId,
-        },
-      });
-
-      recipients = recipients.filter((recipient) =>
-        recipient.subscribedToEventType(NotificationEventType.CreateComment)
-      );
-    } else {
-      recipients = await this.getDocumentNotificationRecipients({
-        document,
-        notificationType: NotificationEventType.CreateComment,
-        actorId,
-        // We will check below, this just prevents duplicate queries
-        disableAccessCheck: true,
-      });
+      ]);
+      recipients = recipients.filter((r) => userIdsInThread.includes(r.id));
     }
 
     const filtered: User[] = [];
 
     for (const recipient of recipients) {
-      if (recipient.isSuspended) {
-        continue;
-      }
-
       // If this recipient has viewed the document since the comment was made
       // then we can avoid sending them a useless notification, yay.
       const view = await View.findOne({
@@ -137,13 +119,7 @@ export default class NotificationHelper {
           "processor",
           `suppressing notification to ${recipient.id} because doc viewed`
         );
-        continue;
-      }
-
-      // Check the recipient has access to the collection this document is in. Just
-      // because they are subscribed doesn't mean they still have access to read
-      // the document.
-      if (await canUserAccessDocument(recipient, document.id)) {
+      } else {
         filtered.push(recipient);
       }
     }
@@ -156,36 +132,24 @@ export default class NotificationHelper {
    *
    * @param document The document to get recipients for.
    * @param notificationType The notification type for which to find the recipients.
+   * @param onlySubscribers Whether to consider only the users who have active subscription to the document.
    * @param actorId The id of the user that performed the action.
-   * @param disableAccessCheck Whether to disable the access check for the document.
    * @returns A list of recipients
    */
   public static getDocumentNotificationRecipients = async ({
     document,
     notificationType,
+    onlySubscribers,
     actorId,
-    disableAccessCheck = false,
   }: {
     document: Document;
     notificationType: NotificationEventType;
+    onlySubscribers: boolean;
     actorId: string;
-    disableAccessCheck?: boolean;
   }): Promise<User[]> => {
     let recipients: User[];
 
-    if (notificationType === NotificationEventType.PublishDocument) {
-      recipients = await User.findAll({
-        where: {
-          id: {
-            [Op.ne]: actorId,
-          },
-          teamId: document.teamId,
-          notificationSettings: {
-            [notificationType]: true,
-          },
-        },
-      });
-    } else {
+    if (onlySubscribers) {
       const subscriptions = await Subscription.findAll({
         attributes: ["userId"],
         where: {
@@ -201,12 +165,20 @@ export default class NotificationHelper {
         include: [
           {
             association: "user",
-            required: true,
           },
         ],
       });
 
       recipients = subscriptions.map((s) => s.user);
+    } else {
+      recipients = await User.findAll({
+        where: {
+          id: {
+            [Op.ne]: actorId,
+          },
+          teamId: document.teamId,
+        },
+      });
     }
 
     recipients = recipients.filter((recipient) =>
@@ -216,17 +188,18 @@ export default class NotificationHelper {
     const filtered = [];
 
     for (const recipient of recipients) {
-      if (recipient.isSuspended) {
+      if (!recipient.email || recipient.isSuspended) {
         continue;
       }
 
       // Check the recipient has access to the collection this document is in. Just
       // because they are subscribed doesn't mean they still have access to read
       // the document.
-      if (
-        disableAccessCheck ||
-        (await canUserAccessDocument(recipient, document.id))
-      ) {
+      const doc = await Document.findByPk(document.id, {
+        userId: recipient.id,
+      });
+
+      if (can(recipient, "read", doc)) {
         filtered.push(recipient);
       }
     }

server/presenters/import.ts

@@ -11,7 +11,6 @@ export default function presentImport(
     service: importModel.service,
     state: importModel.state,
     documentCount: importModel.documentCount,
-    error: importModel.error,
     createdBy: presentUser(importModel.createdBy),
     createdById: importModel.createdById,
     createdAt: importModel.createdAt,

server/queues/processors/DocumentSubscriptionProcessor.ts

@@ -1,85 +1,44 @@
+import { Op } from "sequelize";
 import { GroupUser } from "@server/models";
-import {
-  CollectionGroupEvent,
-  CollectionUserEvent,
-  DocumentGroupEvent,
-  DocumentUserEvent,
-  Event,
-} from "@server/types";
-import CollectionSubscriptionRemoveUserTask from "../tasks/CollectionSubscriptionRemoveUserTask";
-import DocumentSubscriptionRemoveUserTask from "../tasks/DocumentSubscriptionRemoveUserTask";
+import { DocumentGroupEvent, DocumentUserEvent, Event } from "@server/types";
+import DocumentSubscriptionTask from "../tasks/DocumentSubscriptionTask";
 import BaseProcessor from "./BaseProcessor";
 
-type ReceivedEvent =
-  | CollectionUserEvent
-  | CollectionGroupEvent
-  | DocumentUserEvent
-  | DocumentGroupEvent;
-
 export default class DocumentSubscriptionProcessor extends BaseProcessor {
   static applicableEvents: Event["name"][] = [
-    "collections.remove_user",
-    "collections.remove_group",
     "documents.remove_user",
     "documents.remove_group",
   ];
 
-  async perform(event: ReceivedEvent) {
+  async perform(event: DocumentUserEvent | DocumentGroupEvent) {
     switch (event.name) {
-      case "collections.remove_user": {
-        await CollectionSubscriptionRemoveUserTask.schedule(event);
-        return;
-      }
-
-      case "collections.remove_group":
-        return this.handleRemoveGroupFromCollection(event);
-
       case "documents.remove_user": {
-        await DocumentSubscriptionRemoveUserTask.schedule(event);
+        await DocumentSubscriptionTask.schedule(event);
         return;
       }
 
       case "documents.remove_group":
-        return this.handleRemoveGroupFromDocument(event);
+        return this.handleGroup(event);
 
       default:
     }
   }
 
-  private async handleRemoveGroupFromCollection(event: CollectionGroupEvent) {
+  private async handleGroup(event: DocumentGroupEvent) {
     await GroupUser.findAllInBatches<GroupUser>(
       {
         where: {
           groupId: event.modelId,
+          userId: {
+            [Op.ne]: event.actorId,
+          },
         },
         batchLimit: 10,
       },
       async (groupUsers) => {
         await Promise.all(
           groupUsers.map((groupUser) =>
-            CollectionSubscriptionRemoveUserTask.schedule({
-              ...event,
-              name: "collections.remove_user",
-              userId: groupUser.userId,
-            })
-          )
-        );
-      }
-    );
-  }
-
-  private async handleRemoveGroupFromDocument(event: DocumentGroupEvent) {
-    await GroupUser.findAllInBatches<GroupUser>(
-      {
-        where: {
-          groupId: event.modelId,
-        },
-        batchLimit: 10,
-      },
-      async (groupUsers) => {
-        await Promise.all(
-          groupUsers.map((groupUser) =>
-            DocumentSubscriptionRemoveUserTask.schedule({
+            DocumentSubscriptionTask.schedule({
               ...event,
               name: "documents.remove_user",
               userId: groupUser.userId,

server/queues/processors/ImportsProcessor.ts

@@ -49,46 +49,33 @@ export default abstract class ImportsProcessor<
    * @param event The import event
    */
   public async perform(event: ImportEvent) {
-    try {
-      await sequelize.transaction(async (transaction) => {
-        const importModel = await Import.findByPk<Import<T>>(event.modelId, {
-          rejectOnEmpty: true,
-          paranoid: false,
-          transaction,
-          lock: transaction.LOCK.UPDATE,
-        });
-
-        if (
-          !this.canProcess(importModel) ||
-          importModel.state === ImportState.Errored ||
-          importModel.state === ImportState.Canceled
-        ) {
-          return;
-        }
-
-        switch (event.name) {
-          case "imports.create":
-            return this.onCreation(importModel, transaction);
-
-          case "imports.processed":
-            return this.onProcessed(importModel, transaction);
-
-          case "imports.delete":
-            return this.onDeletion(importModel, event, transaction);
-        }
+    await sequelize.transaction(async (transaction) => {
+      const importModel = await Import.findByPk<Import<T>>(event.modelId, {
+        rejectOnEmpty: true,
+        paranoid: false,
+        transaction,
+        lock: transaction.LOCK.UPDATE,
       });
-    } catch (err) {
-      if (event.name !== "imports.delete" && err instanceof Error) {
-        const importModel = await Import.findByPk<Import<T>>(event.modelId, {
-          rejectOnEmpty: true,
-          paranoid: false,
-        });
-        importModel.error = truncate(err.message, { length: 255 });
-        await importModel.save();
+
+      if (
+        !this.canProcess(importModel) ||
+        importModel.state === ImportState.Errored ||
+        importModel.state === ImportState.Canceled
+      ) {
+        return;
       }
 
-      throw err; // throw error for retry.
-    }
+      switch (event.name) {
+        case "imports.create":
+          return this.onCreation(importModel, transaction);
+
+        case "imports.processed":
+          return this.onProcessed(importModel, transaction);
+
+        case "imports.delete":
+          return this.onDeletion(importModel, event, transaction);
+      }
+    });
   }
 
   public async onFailed(event: ImportEvent) {
@@ -186,7 +173,6 @@ export default abstract class ImportsProcessor<
     }
 
     importModel.state = ImportState.Completed;
-    importModel.error = null; // unset any error from previous attempts.
     await importModel.saveWithCtx(
       createContext({
         user: importModel.createdBy,

server/queues/tasks/APIImportTask.ts

@@ -1,6 +1,5 @@
 import { JobOptions } from "bull";
 import chunk from "lodash/chunk";
-import truncate from "lodash/truncate";
 import uniqBy from "lodash/uniqBy";
 import { Fragment, Node } from "prosemirror-model";
 import { Transaction, WhereOptions } from "sequelize";
@@ -64,29 +63,20 @@ export default abstract class APIImportTask<
       return;
     }
 
-    try {
-      switch (importTask.state) {
-        case ImportTaskState.Created: {
-          importTask.state = ImportTaskState.InProgress;
-          importTask = await importTask.save();
-          return await this.onProcess(importTask);
-        }
-
-        case ImportTaskState.InProgress:
-          return await this.onProcess(importTask);
-
-        case ImportTaskState.Completed:
-          return await this.onCompletion(importTask);
-
-        default:
-      }
-    } catch (err) {
-      if (err instanceof Error) {
-        importTask.error = truncate(err.message, { length: 255 });
-        await importTask.save();
+    switch (importTask.state) {
+      case ImportTaskState.Created: {
+        importTask.state = ImportTaskState.InProgress;
+        importTask = await importTask.save();
+        return await this.onProcess(importTask);
       }
 
-      throw err; // throw error for retry.
+      case ImportTaskState.InProgress:
+        return await this.onProcess(importTask);
+
+      case ImportTaskState.Completed:
+        return await this.onCompletion(importTask);
+
+      default:
     }
   }
 
@@ -118,7 +108,6 @@ export default abstract class APIImportTask<
       await importTask.save({ transaction });
 
       const associatedImport = importTask.import;
-      associatedImport.error = importTask.error; // copy error from ImportTask that caused the failure.
       associatedImport.state = ImportState.Errored;
       await associatedImport.saveWithCtx(
         createContext({
@@ -166,7 +155,6 @@ export default abstract class APIImportTask<
 
       importTask.output = taskOutputWithReplacements;
       importTask.state = ImportTaskState.Completed;
-      importTask.error = null; // unset any error from previous attempts.
       await importTask.save({ transaction });
 
       const associatedImport = importTask.import;

server/queues/tasks/CleanupOldImportsTask.ts

@@ -41,7 +41,6 @@ export default class CleanupOldImportsTask extends BaseTask<Props> {
           ],
           batchLimit: 50,
           totalLimit: maxImportsPerTask,
-          paranoid: false,
         },
         async (imports) => {
           // eslint-disable-next-line @typescript-eslint/no-explicit-any

server/queues/tasks/CollectionSubscriptionRemoveUserTask.ts

@@ -1,52 +0,0 @@
-import { Transaction } from "sequelize";
-import { SubscriptionType } from "@shared/types";
-import { createContext } from "@server/context";
-import Logger from "@server/logging/Logger";
-import { Collection, Subscription, User } from "@server/models";
-import { can } from "@server/policies";
-import { sequelize } from "@server/storage/database";
-import { CollectionUserEvent } from "@server/types";
-import BaseTask from "./BaseTask";
-
-export default class CollectionSubscriptionRemoveUserTask extends BaseTask<CollectionUserEvent> {
-  public async perform(event: CollectionUserEvent) {
-    const user = await User.findByPk(event.userId);
-
-    if (!user) {
-      return;
-    }
-
-    const collection = await Collection.scope({
-      method: ["withMembership", user.id],
-    }).findByPk(event.collectionId);
-
-    if (can(user, "read", collection)) {
-      Logger.debug(
-        "task",
-        `Skip unsubscribing user ${user.id} as they have permission to the collection ${event.collectionId} through other means`
-      );
-      return;
-    }
-
-    await sequelize.transaction(async (transaction) => {
-      const subscription = await Subscription.findOne({
-        where: {
-          userId: user.id,
-          collectionId: event.collectionId,
-          event: SubscriptionType.Document,
-        },
-        transaction,
-        lock: Transaction.LOCK.UPDATE,
-      });
-
-      await subscription?.destroyWithCtx(
-        createContext({
-          user,
-          authType: event.authType,
-          ip: event.ip,
-          transaction,
-        })
-      );
-    });
-  }
-}

server/queues/tasks/DocumentPublishedNotificationsTask.ts

@@ -54,6 +54,7 @@ export default class DocumentPublishedNotificationsTask extends BaseTask<Documen
       await NotificationHelper.getDocumentNotificationRecipients({
         document,
         notificationType: NotificationEventType.PublishDocument,
+        onlySubscribers: false,
         actorId: document.lastModifiedById,
       })
     ).filter((recipient) => !userIdsMentioned.includes(recipient.id));

server/queues/tasks/DocumentSubscriptionTask.ts

@@ -8,11 +8,11 @@ import { sequelize } from "@server/storage/database";
 import { DocumentUserEvent } from "@server/types";
 import BaseTask from "./BaseTask";
 
-export default class DocumentSubscriptionRemoveUserTask extends BaseTask<DocumentUserEvent> {
+export default class DocumentSubscriptionTask extends BaseTask<DocumentUserEvent> {
   public async perform(event: DocumentUserEvent) {
     const user = await User.findByPk(event.userId);
 
-    if (!user) {
+    if (!user || event.name !== "documents.remove_user") {
       return;
     }
 

server/queues/tasks/ErrorTimedOutImportsTask.ts

@@ -56,13 +56,11 @@ export default class ErrorTimedOutImportsTask extends BaseTask<Props> {
 
             await sequelize.transaction(async (transaction) => {
               importTask.state = ImportTaskState.Errored;
-              importTask.error = "Timed out";
               await importTask.save({ transaction });
 
               // this import could have been seen before in another import_task.
               if (!importsErrored[associatedImport.id]) {
                 associatedImport.state = ImportState.Errored;
-                associatedImport.error = "Timed out";
                 await associatedImport.save({ transaction });
                 importsErrored[associatedImport.id] = true;
               }

server/queues/tasks/RevisionCreatedNotificationsTask.ts

@@ -76,6 +76,7 @@ export default class RevisionCreatedNotificationsTask extends BaseTask<RevisionE
       await NotificationHelper.getDocumentNotificationRecipients({
         document,
         notificationType: NotificationEventType.UpdateDocument,
+        onlySubscribers: true,
         actorId: document.lastModifiedById,
       })
     ).filter((recipient) => !userIdsMentioned.includes(recipient.id));

shared/components/EventBoundary.tsx

@@ -10,10 +10,6 @@ type Props = {
   captureEvents?: "all" | "pointer" | "click";
 };
 
-/**
- * EventBoundary is a component that prevents events from propagating to parent elements.
- * This is useful for preventing clicks or other interactions from bubbling up the DOM tree.
- */
 const EventBoundary: React.FC<Props> = ({
   children,
   className,

shared/components/Flex.tsx

@@ -5,26 +5,14 @@ type JustifyValues = CSSProperties["justifyContent"];
 
 type AlignValues = CSSProperties["alignItems"];
 
-/**
- * Flex is a styled component that provides a flexible box layout with convenient props.
- * It simplifies the use of flexbox CSS properties with a clean, declarative API.
- */
 const Flex = styled.div<{
-  /** Makes the component grow to fill available space */
   auto?: boolean;
-  /** Changes flex direction to column */
   column?: boolean;
-  /** Sets the align-items CSS property */
   align?: AlignValues;
-  /** Sets the justify-content CSS property */
   justify?: JustifyValues;
-  /** Enables flex-wrap */
   wrap?: boolean;
-  /** Controls flex-shrink behavior */
   shrink?: boolean;
-  /** Reverses the direction (row-reverse or column-reverse) */
   reverse?: boolean;
-  /** Sets gap between flex items in pixels */
   gap?: number;
 }>`
   display: flex;

shared/components/Squircle.tsx

@@ -11,11 +11,6 @@ type Props = {
   className?: string;
 };
 
-/**
- * Squircle is a component that renders a square with rounded corners (squircle shape).
- * It's commonly used for app icons, avatars, and other UI elements where a softer
- * square shape is desired.
- */
 const Squircle: React.FC<Props> = ({
   color,
   size = 28,

shared/editor/commands/toggleList.ts

@@ -1,5 +1,5 @@
 import { NodeType } from "prosemirror-model";
-import { liftListItem, wrapInList } from "prosemirror-schema-list";
+import { wrapInList, liftListItem } from "prosemirror-schema-list";
 import { Command } from "prosemirror-state";
 import { chainTransactions } from "../lib/chainTransactions";
 import { findParentNode } from "../queries/findParentNode";
@@ -29,14 +29,6 @@ export default function toggleList(
         return liftListItem(itemType)(state, dispatch);
       }
 
-      const currentItemType = parentList.node.content.firstChild?.type;
-      if (currentItemType && currentItemType !== itemType) {
-        return chainTransactions(clearNodes(), wrapInList(listType))(
-          state,
-          dispatch
-        );
-      }
-
       if (
         isList(parentList.node, schema) &&
         listType.validContent(parentList.node.content)

shared/editor/nodes/Mention.tsx

@@ -32,11 +32,6 @@ export default class Mention extends Node {
   }
 
   get schema(): NodeSpec {
-    const toPlainText = (node: ProsemirrorNode) =>
-      node.attrs.type === MentionType.User
-        ? `@${node.attrs.label}`
-        : node.attrs.label;
-
     return {
       attrs: {
         type: {
@@ -93,9 +88,12 @@ export default class Mention extends Node {
           "data-actorid": node.attrs.actorId,
           "data-url": `mention://${node.attrs.id}/${node.attrs.type}/${node.attrs.modelId}`,
         },
-        toPlainText(node),
+        String(node.attrs.label),
       ],
-      toPlainText,
+      toPlainText: (node) =>
+        node.attrs.type === MentionType.User
+          ? `@${node.attrs.label}`
+          : node.attrs.label,
     };
   }