Store import error in DB

.github/workflows/lint.yml

@@ -1,30 +0,0 @@
-name: Lint
-
-on:
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  run-linters:
-    if: startsWith(github.actor, 'codegen-sh')
-    name: Run linters
-    runs-on: ubuntu-latest
-
-    permissions:
-      # Give the default GITHUB_TOKEN write permission to commit and push the
-      # added or changed files to the repository.
-      contents: write
-
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20.x
-          cache: 'yarn'
-      - run: yarn install --frozen-lockfile
-      - run: yarn lint --fix
-
-      - name: Commit changes
-        uses: stefanzweifel/git-auto-commit-action@v5
-        with:
-          commit_message: 'Applied automatic fixes'

app/components/AuthenticatedLayout.tsx

@@ -1,13 +1,7 @@
 import { AnimatePresence } from "framer-motion";
 import { observer } from "mobx-react";
 import * as React from "react";
-import {
-  Switch,
-  Route,
-  useLocation,
-  matchPath,
-  Redirect,
-} from "react-router-dom";
+import { Switch, Route, useLocation, matchPath } from "react-router-dom";
 import { TeamPreference } from "@shared/types";
 import ErrorSuspended from "~/scenes/Errors/ErrorSuspended";
 import Layout from "~/components/Layout";
@@ -16,7 +10,6 @@ import Sidebar from "~/components/Sidebar";
 import SidebarRight from "~/components/Sidebar/Right";
 import SettingsSidebar from "~/components/Sidebar/Settings";
 import useCurrentTeam from "~/hooks/useCurrentTeam";
-import { usePostLoginPath } from "~/hooks/useLastVisitedPath";
 import usePolicy from "~/hooks/usePolicy";
 import useStores from "~/hooks/useStores";
 import history from "~/utils/history";
@@ -55,7 +48,6 @@ const AuthenticatedLayout: React.FC = ({ children }: Props) => {
   const can = usePolicy(ui.activeDocumentId);
   const canCollection = usePolicy(ui.activeCollectionId);
   const team = useCurrentTeam();
-  const [spendPostLoginPath] = usePostLoginPath();
 
   const goToSearch = (ev: KeyboardEvent) => {
     if (!ev.metaKey && !ev.ctrlKey) {
@@ -80,11 +72,6 @@ const AuthenticatedLayout: React.FC = ({ children }: Props) => {
     return <ErrorSuspended />;
   }
 
-  const postLoginPath = spendPostLoginPath();
-  if (postLoginPath) {
-    return <Redirect to={postLoginPath} />;
-  }
-
   const sidebar = (
     <Fade>
       <Switch>

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/components/Fade.tsx

@@ -2,11 +2,6 @@ import React from "react";
 import styled from "styled-components";
 import { fadeIn } from "~/styles/animations";
 
-/**
- * Fade in animation for a component.
- *
- * @param timing - The duration of the fade in animation, default is 250ms.
- */
 const Fade = styled.span<{ timing?: number | string }>`
   animation: ${fadeIn} ${(props) => props.timing || "250ms"} ease-in-out;
 `;
@@ -22,6 +17,7 @@ type Props = {
  */
 export const ConditionalFade = ({ animate, children }: Props) => {
   const [isAnimated] = React.useState(animate);
+
   return isAnimated ? <Fade>{children}</Fade> : <>{children}</>;
 };
 

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/editor/extensions/PasteHandler.tsx

@@ -88,7 +88,7 @@ export default class PasteHandler extends Extension {
 
             // If the users selection is currently in a code block then paste
             // as plain text, ignore all formatting and HTML content.
-            if (isInCode(state, { inclusive: true })) {
+            if (isInCode(state)) {
               event.preventDefault();
               view.dispatch(state.tr.insertText(text));
               return true;

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/scenes/Document/components/CommentThread.tsx

@@ -16,7 +16,6 @@ import { useDocumentContext } from "~/components/DocumentContext";
 import Facepile from "~/components/Facepile";
 import Fade from "~/components/Fade";
 import { ResizingHeightContainer } from "~/components/ResizingHeightContainer";
-import useBoolean from "~/hooks/useBoolean";
 import { useLocationSidebarContext } from "~/hooks/useLocationSidebarContext";
 import useOnClickOutside from "~/hooks/useOnClickOutside";
 import usePersistedState from "~/hooks/usePersistedState";
@@ -64,7 +63,7 @@ function CommentThread({
   const history = useHistory();
   const location = useLocation();
   const sidebarContext = useLocationSidebarContext();
-  const [autoFocus, setAutoFocusOn, setAutoFocusOff] = useBoolean(thread.isNew);
+  const [autoFocus, setAutoFocus] = React.useState(thread.isNew);
 
   const can = usePolicy(document);
 
@@ -157,9 +156,9 @@ function CommentThread({
 
   React.useEffect(() => {
     if (!focused && autoFocus) {
-      setAutoFocusOff();
+      setAutoFocus(false);
     }
-  }, [focused, autoFocus, setAutoFocusOff]);
+  }, [focused, autoFocus]);
 
   React.useEffect(() => {
     if (focused) {
@@ -274,7 +273,7 @@ function CommentThread({
         )}
       </ResizingHeightContainer>
       {!focused && !recessed && !draft && canReply && (
-        <Reply onClick={setAutoFocusOn}>{t("Reply")}…</Reply>
+        <Reply onClick={() => setAutoFocus(true)}>{t("Reply")}…</Reply>
       )}
     </Thread>
   );

app/scenes/Home.tsx

@@ -2,7 +2,7 @@ import { observer } from "mobx-react";
 import { HomeIcon } from "outline-icons";
 import * as React from "react";
 import { useTranslation } from "react-i18next";
-import { Switch, Route } from "react-router-dom";
+import { Switch, Route, Redirect } from "react-router-dom";
 import styled from "styled-components";
 import { s } from "@shared/styles";
 import { Action } from "~/components/Actions";
@@ -18,6 +18,7 @@ import Tab from "~/components/Tab";
 import Tabs from "~/components/Tabs";
 import useCurrentTeam from "~/hooks/useCurrentTeam";
 import useCurrentUser from "~/hooks/useCurrentUser";
+import { usePostLoginPath } from "~/hooks/useLastVisitedPath";
 import { usePinnedDocuments } from "~/hooks/usePinnedDocuments";
 import usePolicy from "~/hooks/usePolicy";
 import useStores from "~/hooks/useStores";
@@ -28,10 +29,16 @@ function Home() {
   const team = useCurrentTeam();
   const user = useCurrentUser();
   const { t } = useTranslation();
+  const [spendPostLoginPath] = usePostLoginPath();
   const userId = user?.id;
   const { pins, count } = usePinnedDocuments("home");
   const can = usePolicy(team);
 
+  const postLoginPath = spendPostLoginPath();
+  if (postLoginPath) {
+    return <Redirect to={postLoginPath} />;
+  }
+
   return (
     <Scene
       icon={<HomeIcon />}

app/scenes/Settings/components/ImportNotionDialog.tsx

@@ -0,0 +1,36 @@
+import * as React from "react";
+import { Trans, useTranslation } from "react-i18next";
+import { FileOperationFormat } from "@shared/types";
+import useStores from "~/hooks/useStores";
+import DropToImport from "./DropToImport";
+import HelpDisclosure from "./HelpDisclosure";
+
+function ImportNotionDialog() {
+  const { t } = useTranslation();
+  const { dialogs } = useStores();
+
+  return (
+    <>
+      <HelpDisclosure title={<Trans>Where do I find the file?</Trans>}>
+        <Trans
+          defaults="In Notion, click <em>Settings & Members</em> in the left sidebar and open Settings. Look for the Export section, and click <em>Export all workspace content</em>. Choose <em>HTML</em> as the format for the best data compatability."
+          components={{
+            em: <strong />,
+          }}
+        />
+      </HelpDisclosure>
+      <DropToImport
+        onSubmit={dialogs.closeAllModals}
+        format={FileOperationFormat.Notion}
+      >
+        <>
+          {t(
+            `Drag and drop the zip file from Notion's HTML export option, or click to upload`
+          )}
+        </>
+      </DropToImport>
+    </>
+  );
+}
+
+export default ImportNotionDialog;

package.json

@@ -48,11 +48,11 @@
     "> 0.25%, not dead"
   ],
   "dependencies": {
-    "@aws-sdk/client-s3": "3.777.0",
-    "@aws-sdk/lib-storage": "3.777.0",
-    "@aws-sdk/s3-presigned-post": "3.777.0",
-    "@aws-sdk/s3-request-presigner": "3.777.0",
-    "@aws-sdk/signature-v4-crt": "^3.775.0",
+    "@aws-sdk/client-s3": "3.774.0",
+    "@aws-sdk/lib-storage": "3.774.0",
+    "@aws-sdk/s3-presigned-post": "3.774.0",
+    "@aws-sdk/s3-request-presigner": "3.774.0",
+    "@aws-sdk/signature-v4-crt": "^3.774.0",
     "@babel/core": "^7.26.10",
     "@babel/plugin-proposal-decorators": "^7.25.9",
     "@babel/plugin-transform-class-properties": "^7.25.9",
@@ -89,7 +89,7 @@
     "@sentry/node": "^7.120.3",
     "@sentry/react": "^7.120.3",
     "@tanstack/react-table": "^8.20.6",
-    "@tanstack/react-virtual": "^3.13.6",
+    "@tanstack/react-virtual": "^3.11.3",
     "@tippyjs/react": "^4.2.6",
     "@types/form-data": "^2.5.2",
     "@types/mailparser": "^3.4.5",
@@ -185,8 +185,8 @@
     "prosemirror-history": "^1.4.1",
     "prosemirror-inputrules": "^1.4.0",
     "prosemirror-keymap": "^1.2.2",
-    "prosemirror-markdown": "^1.13.2",
-    "prosemirror-model": "^1.25.0",
+    "prosemirror-markdown": "^1.13.1",
+    "prosemirror-model": "^1.24.0",
     "prosemirror-schema-list": "^1.4.1",
     "prosemirror-state": "^1.4.3",
     "prosemirror-tables": "^1.6.4",
@@ -248,7 +248,7 @@
     "uuid": "^8.3.2",
     "validator": "13.12.0",
     "vaul": "^1.1.2",
-    "vite": "^5.4.16",
+    "vite": "^5.4.15",
     "vite-plugin-pwa": "^0.20.3",
     "winston": "^3.17.0",
     "ws": "^7.5.10",
@@ -263,7 +263,7 @@
     "@babel/cli": "^7.27.0",
     "@babel/preset-typescript": "^7.27.0",
     "@faker-js/faker": "^8.4.1",
-    "@relative-ci/agent": "^4.3.0",
+    "@relative-ci/agent": "^4.2.14",
     "@testing-library/react": "^12.0.0",
     "@types/addressparser": "^1.0.3",
     "@types/body-scroll-lock": "^3.1.2",

plugins/notion/server/tasks/NotionAPIImportTask.ts

@@ -1,8 +1,6 @@
-import { APIResponseError, APIErrorCode } from "@notionhq/client";
 import { ImportTaskInput, ImportTaskOutput } from "@shared/schema";
 import { IntegrationService, ProsemirrorDoc } from "@shared/types";
 import { ProsemirrorHelper } from "@shared/utils/ProsemirrorHelper";
-import Logger from "@server/logging/Logger";
 import { Integration } from "@server/models";
 import ImportTask from "@server/models/ImportTask";
 import APIImportTask, {
@@ -41,10 +39,7 @@ export default class NotionAPIImportTask extends APIImportTask<IntegrationServic
       importTask.input.map(async (item) => this.processPage({ item, client }))
     );
 
-    // Filter out any null results (from pages/databases that couldn't be accessed)
-    const validParsedPages = parsedPages.filter(Boolean) as ParsePageOutput[];
-
-    const taskOutput: ImportTaskOutput = validParsedPages.map((parsedPage) => ({
+    const taskOutput: ImportTaskOutput = parsedPages.map((parsedPage) => ({
       externalId: parsedPage.externalId,
       title: parsedPage.title,
       emoji: parsedPage.emoji,
@@ -55,7 +50,7 @@ export default class NotionAPIImportTask extends APIImportTask<IntegrationServic
     }));
 
     const childTasksInput: ImportTaskInput<IntegrationService.Notion> =
-      validParsedPages.flatMap((parsedPage) =>
+      parsedPages.flatMap((parsedPage) =>
         parsedPage.children.map((childPage) => ({
           type: childPage.type,
           externalId: childPage.externalId,
@@ -93,55 +88,36 @@ export default class NotionAPIImportTask extends APIImportTask<IntegrationServic
   }: {
     item: ImportTaskInput<IntegrationService.Notion>[number];
     client: NotionClient;
-  }): Promise<ParsePageOutput | null> {
+  }): Promise<ParsePageOutput> {
     const collectionExternalId = item.collectionExternalId ?? item.externalId;
 
-    try {
-      // Convert Notion database to an empty page with "pages in database" as its children.
-      if (item.type === PageType.Database) {
-        const { pages, ...databaseInfo } = await client.fetchDatabase(
-          item.externalId
-        );
-
-        return {
-          ...databaseInfo,
-          externalId: item.externalId,
-          content: ProsemirrorHelper.getEmptyDocument() as ProsemirrorDoc,
-          collectionExternalId,
-          children: pages.map((page) => ({
-            type: page.type,
-            externalId: page.id,
-          })),
-        };
-      }
-
-      const { blocks, ...pageInfo } = await client.fetchPage(item.externalId);
+    // Convert Notion database to an empty page with "pages in database" as its children.
+    if (item.type === PageType.Database) {
+      const { pages, ...databaseInfo } = await client.fetchDatabase(
+        item.externalId
+      );
 
       return {
-        ...pageInfo,
+        ...databaseInfo,
         externalId: item.externalId,
-        content: NotionConverter.page({ children: blocks } as NotionPage),
+        content: ProsemirrorHelper.getEmptyDocument() as ProsemirrorDoc,
         collectionExternalId,
-        children: this.parseChildPages(blocks),
+        children: pages.map((page) => ({
+          type: page.type,
+          externalId: page.id,
+        })),
       };
-    } catch (error) {
-      if (error instanceof APIResponseError) {
-        // Skip this page/database if it's not found or not accessible
-        if (
-          error.code === APIErrorCode.ObjectNotFound ||
-          error.code === APIErrorCode.Unauthorized
-        ) {
-          Logger.warn(
-            `Skipping Notion ${
-              item.type === PageType.Database ? "database" : "page"
-            } ${item.externalId} - Error code: ${error.code} - ${error.message}`
-          );
-          return null;
-        }
-      }
-      // Re-throw other errors to be handled by the parent try/catch
-      throw error;
     }
+
+    const { blocks, ...pageInfo } = await client.fetchPage(item.externalId);
+
+    return {
+      ...pageInfo,
+      externalId: item.externalId,
+      content: NotionConverter.page({ children: blocks } as NotionPage),
+      collectionExternalId,
+      children: this.parseChildPages(blocks),
+    };
   }
 
   /**

server/collaboration/ConnectionLimitExtension.test.ts

@@ -1,109 +0,0 @@
-import { Server } from "@hocuspocus/server";
-import WebSocket from "ws";
-import EDITOR_VERSION from "@shared/editor/version";
-import { sleep } from "@server/utils/timers";
-import { ConnectionLimitExtension } from "./ConnectionLimitExtension";
-import { EditorVersionExtension } from "./EditorVersionExtension";
-
-jest.mock("@server/env", () => ({
-  COLLABORATION_MAX_CLIENTS_PER_DOCUMENT: 2,
-}));
-
-describe("ConnectionLimitExtension", () => {
-  let server: typeof Server;
-  let extension: ConnectionLimitExtension;
-  const port = 12345;
-  const url = `ws://localhost:${port}`;
-  const documentName = "test";
-
-  beforeEach(async () => {
-    extension = new ConnectionLimitExtension();
-    server = Server.configure({
-      port,
-      extensions: [extension, new EditorVersionExtension()],
-    });
-    await server.listen();
-  });
-
-  afterEach(async () => {
-    await server.destroy();
-  });
-
-  const getConnections = () =>
-    extension.connectionsByDocument.get(documentName)?.size ?? 0;
-
-  const createWebSocket = (editorVersion = EDITOR_VERSION) =>
-    new Promise<WebSocket>((resolve, reject) => {
-      const ws = new WebSocket(
-        `${url}/${documentName}?editorVersion=${editorVersion}`
-      );
-      ws.on("open", () => resolve(ws));
-      ws.on("error", reject);
-    });
-
-  it("should allow connections within limit", async () => {
-    const ws1 = await createWebSocket();
-    const ws2 = await createWebSocket();
-
-    expect(ws1.readyState).toBe(WebSocket.OPEN);
-    expect(ws2.readyState).toBe(WebSocket.OPEN);
-    expect(getConnections()).toBe(2);
-
-    ws1.close();
-    ws2.close();
-
-    await sleep(250);
-    expect(getConnections()).toBe(0);
-  });
-
-  it("should close connections exceeding limit", async () => {
-    const ws1 = await createWebSocket();
-    const ws2 = await createWebSocket();
-
-    const ws3 = await createWebSocket();
-    await sleep(250);
-
-    expect(ws3.readyState).toBe(WebSocket.CLOSED);
-    expect(ws2.readyState).toBe(WebSocket.OPEN);
-    expect(ws1.readyState).toBe(WebSocket.OPEN);
-    expect(getConnections()).toBe(2);
-
-    ws1.close();
-    ws2.close();
-
-    await sleep(250);
-    expect(getConnections()).toBe(0);
-  });
-
-  it("should handle connections closed by other extensions", async () => {
-    const ws1 = await createWebSocket();
-
-    // Create a connection that will be closed by the EditorVersionExtension
-    const ws2 = await createWebSocket("1.0.0");
-
-    ws1.close();
-    ws2.close();
-
-    await sleep(250);
-    expect(getConnections()).toBe(0);
-  });
-
-  it("should allow new connection after disconnect", async () => {
-    const ws1 = await createWebSocket();
-    const ws2 = await createWebSocket();
-
-    ws1.close();
-    await sleep(250);
-    expect(getConnections()).toBe(1);
-
-    const ws3 = await createWebSocket();
-    expect(ws3.readyState).toBe(WebSocket.OPEN);
-    expect(getConnections()).toBe(2);
-
-    ws2.close();
-    ws3.close();
-
-    await sleep(250);
-    expect(getConnections()).toBe(0);
-  });
-});

server/collaboration/ConnectionLimitExtension.ts

@@ -1,10 +1,8 @@
 import {
   Extension,
-  connectedPayload,
   onConnectPayload,
   onDisconnectPayload,
 } from "@hocuspocus/server";
-import pluralize from "pluralize";
 import { TooManyConnections } from "@shared/collaboration/CloseEvents";
 import env from "@server/env";
 import Logger from "@server/logging/Logger";
@@ -16,7 +14,7 @@ export class ConnectionLimitExtension implements Extension {
   /**
    * Map of documentId -> connection count
    */
-  public connectionsByDocument: Map<string, Set<string>> = new Map();
+  connectionsByDocument: Map<string, Set<string>> = new Map();
 
   /**
    * On disconnect hook
@@ -36,30 +34,23 @@ export class ConnectionLimitExtension implements Extension {
       }
     }
 
-    const connectionCount = connections?.size ?? 0;
     Logger.debug(
       "multiplayer",
-      `${connectionCount} ${pluralize(
-        "connection",
-        connectionCount
-      )} to "${documentName}"`
+      `${connections?.size} connections to "${documentName}"`
     );
 
     return Promise.resolve();
   }
 
   /**
-   * onConnect hook is called when a new connection has been established.
-   * This is where we can check if the document has reached the maximum number of
-   * connections and reject the connection if it has.
+   * On connect hook
    *
-   * @param data The onConnect payload
-   * @returns Promise, resolving will allow the connection, rejecting will drop.
+   * @param data The connect payload
+   * @returns Promise, resolving will allow the connection, rejecting will drop it
    */
-  onConnect({ documentName }: withContext<onConnectPayload>) {
+  onConnect({ documentName, socketId }: withContext<onConnectPayload>) {
     const connections =
       this.connectionsByDocument.get(documentName) || new Set();
-
     if (connections?.size >= env.COLLABORATION_MAX_CLIENTS_PER_DOCUMENT) {
       Logger.info(
         "multiplayer",
@@ -70,30 +61,12 @@ export class ConnectionLimitExtension implements Extension {
       return Promise.reject(TooManyConnections);
     }
 
-    return Promise.resolve();
-  }
-
-  /**
-   * Connected hook is called after a new connection has been established.
-   * We can safely update the connection count for the document.
-   *
-   * @param data The onConnect payload
-   * @returns Promise
-   */
-  connected({ documentName, socketId }: withContext<connectedPayload>) {
-    const connections =
-      this.connectionsByDocument.get(documentName) || new Set();
-
     connections.add(socketId);
     this.connectionsByDocument.set(documentName, connections);
-    const connectionCount = connections.size ?? 0;
 
     Logger.debug(
       "multiplayer",
-      `${connectionCount} ${pluralize(
-        "connection",
-        connectionCount
-      )} to "${documentName}"`
+      `${connections.size} connections to "${documentName}"`
     );
 
     return Promise.resolve();

server/commands/teamCreator.ts

@@ -3,6 +3,7 @@ import slugify from "slugify";
 import { RESERVED_SUBDOMAINS } from "@shared/utils/domains";
 import { traceFunction } from "@server/logging/tracing";
 import { Team, Event } from "@server/models";
+import { generateAvatarUrl } from "@server/utils/avatars";
 
 type Props = {
   /** The displayed name of the team */
@@ -35,10 +36,13 @@ async function teamCreator({
   ip,
   transaction,
 }: Props): Promise<Team> {
-  // If the service did not provide a logo/avatar then we'll use the default
-  // avatar generation mechanism (colored initials)
+  // If the service did not provide a logo/avatar then we attempt to generate
+  // one via ClearBit, or fallback to colored initials in worst case scenario
   if (!avatarUrl || !avatarUrl.startsWith("http")) {
-    avatarUrl = null;
+    avatarUrl = await generateAvatarUrl({
+      domain,
+      id: subdomain,
+    });
   }
 
   const team = await Team.create(

server/models/Collection.ts

@@ -1,5 +1,4 @@
 /* eslint-disable lines-between-class-members */
-import fractionalIndex from "fractional-index";
 import find from "lodash/find";
 import findIndex from "lodash/findIndex";
 import remove from "lodash/remove";
@@ -12,8 +11,6 @@ import {
   InferAttributes,
   InferCreationAttributes,
   EmptyResultError,
-  type CreateOptions,
-  type UpdateOptions,
 } from "sequelize";
 import {
   Sequelize,
@@ -35,8 +32,6 @@ import {
   BeforeDestroy,
   IsDate,
   AllowNull,
-  BeforeCreate,
-  BeforeUpdate,
 } from "sequelize-typescript";
 import isUUID from "validator/lib/isUUID";
 import type { CollectionSort, ProsemirrorData } from "@shared/types";
@@ -46,9 +41,7 @@ import { sortNavigationNodes } from "@shared/utils/collections";
 import slugify from "@shared/utils/slugify";
 import { CollectionValidation } from "@shared/validations";
 import { ValidationError } from "@server/errors";
-import removeIndexCollision from "@server/utils/removeIndexCollision";
 import { generateUrlId } from "@server/utils/url";
-import { ValidateIndex } from "@server/validation";
 import Document from "./Document";
 import FileOperation from "./FileOperation";
 import Group from "./Group";
@@ -224,8 +217,8 @@ class Collection extends ParanoidModel<
   color: string | null;
 
   @Length({
-    max: ValidateIndex.maxLength,
-    msg: `index must be ${ValidateIndex.maxLength} characters or less`,
+    max: 256,
+    msg: `index must be 256 characters or less`,
   })
   @Column
   index: string | null;
@@ -331,30 +324,6 @@ class Collection extends ParanoidModel<
     }
   }
 
-  @BeforeCreate
-  static async setIndex(model: Collection, options: CreateOptions<Collection>) {
-    if (model.index) {
-      model.index = await removeIndexCollision(model.teamId, model.index, {
-        transaction: options.transaction,
-      });
-      return;
-    }
-
-    const firstCollectionForTeam = await this.findOne({
-      where: {
-        teamId: model.teamId,
-      },
-      order: [
-        // using LC_COLLATE:"C" because we need byte order to drive the sorting
-        Sequelize.literal('"collection"."index" collate "C"'),
-        ["updatedAt", "DESC"],
-      ],
-      ...options,
-    });
-
-    model.index = fractionalIndex(null, firstCollectionForTeam?.index ?? null);
-  }
-
   @AfterCreate
   static async onAfterCreate(
     model: Collection,
@@ -374,18 +343,6 @@ class Collection extends ParanoidModel<
     });
   }
 
-  @BeforeUpdate
-  static async checkIndex(
-    model: Collection,
-    options: UpdateOptions<Collection>
-  ) {
-    if (model.index && model.changed("index")) {
-      model.index = await removeIndexCollision(model.teamId, model.index, {
-        transaction: options.transaction,
-      });
-    }
-  }
-
   // associations
 
   @BelongsTo(() => FileOperation, "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/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/FileOperationCreatedProcessor.ts

@@ -6,6 +6,7 @@ import ExportJSONTask from "../tasks/ExportJSONTask";
 import ExportMarkdownZipTask from "../tasks/ExportMarkdownZipTask";
 import ImportJSONTask from "../tasks/ImportJSONTask";
 import ImportMarkdownZipTask from "../tasks/ImportMarkdownZipTask";
+import ImportNotionTask from "../tasks/ImportNotionTask";
 import BaseProcessor from "./BaseProcessor";
 
 export default class FileOperationCreatedProcessor extends BaseProcessor {
@@ -24,6 +25,11 @@ export default class FileOperationCreatedProcessor extends BaseProcessor {
             fileOperationId: event.modelId,
           });
           break;
+        case FileOperationFormat.Notion:
+          await ImportNotionTask.schedule({
+            fileOperationId: event.modelId,
+          });
+          break;
         case FileOperationFormat.JSON:
           await ImportJSONTask.schedule({
             fileOperationId: event.modelId,

server/queues/processors/ImportsProcessor.ts

@@ -3,12 +3,7 @@ import chunk from "lodash/chunk";
 import keyBy from "lodash/keyBy";
 import truncate from "lodash/truncate";
 import { Fragment, Node } from "prosemirror-model";
-import {
-  CreateOptions,
-  CreationAttributes,
-  Transaction,
-  UniqueConstraintError,
-} from "sequelize";
+import { CreateOptions, CreationAttributes, Transaction } from "sequelize";
 import { v4 as uuidv4 } from "uuid";
 import { randomElement } from "@shared/random";
 import { ImportInput, ImportTaskInput } from "@shared/schema";
@@ -159,59 +154,45 @@ export default abstract class ImportsProcessor<
    * @returns Promise that resolves when mapping and persistence is completed.
    */
   private async onProcessed(importModel: Import<T>, transaction: Transaction) {
-    try {
-      const { collections } = await this.createCollectionsAndDocuments({
-        importModel,
-        transaction,
-      });
+    const { collections } = await this.createCollectionsAndDocuments({
+      importModel,
+      transaction,
+    });
 
-      // Once all collections and documents are created, update collection's document structure.
-      // This ensures the root documents have the whole subtree available in the structure.
-      for (const collection of collections) {
-        await Document.unscoped().findAllInBatches<Document>(
-          {
-            where: { parentDocumentId: null, collectionId: collection.id },
-            order: [
-              ["createdAt", "DESC"],
-              ["id", "ASC"],
-            ],
-            transaction,
-          },
-          async (documents) => {
-            for (const document of documents) {
-              await collection.addDocumentToStructure(document, 0, {
-                save: false,
-                silent: true,
-                transaction,
-              });
-            }
-          }
-        );
-
-        await collection.save({ silent: true, transaction });
-      }
-
-      importModel.state = ImportState.Completed;
-      importModel.error = null; // unset any error from previous attempts.
-      await importModel.saveWithCtx(
-        createContext({
-          user: importModel.createdBy,
+    // Once all collections and documents are created, update collection's document structure.
+    // This ensures the root documents have the whole subtree available in the structure.
+    for (const collection of collections) {
+      await Document.unscoped().findAllInBatches<Document>(
+        {
+          where: { parentDocumentId: null, collectionId: collection.id },
+          order: [
+            ["createdAt", "DESC"],
+            ["id", "ASC"],
+          ],
           transaction,
-        })
-      );
-    } catch (err) {
-      if (err instanceof UniqueConstraintError) {
-        Logger.error(
-          "ImportsProcessor persistence failed due to unique constraint error",
-          err,
-          {
-            fields: err.fields,
+        },
+        async (documents) => {
+          for (const document of documents) {
+            await collection.addDocumentToStructure(document, 0, {
+              save: false,
+              silent: true,
+              transaction,
+            });
           }
-        );
-      }
+        }
+      );
 
-      throw err;
+      await collection.save({ silent: true, transaction });
     }
+
+    importModel.state = ImportState.Completed;
+    importModel.error = null; // unset any error from previous attempts.
+    await importModel.saveWithCtx(
+      createContext({
+        user: importModel.createdBy,
+        transaction,
+      })
+    );
   }
 
   /**
@@ -323,15 +304,6 @@ export default abstract class ImportsProcessor<
 
             const output = outputMap[externalId];
 
-            // Skip this item if it has no output (likely due to an error during processing)
-            if (!output) {
-              Logger.debug(
-                "processor",
-                `Skipping item with no output: ${externalId}`
-              );
-              continue;
-            }
-
             const collectionItem = importInput[externalId];
 
             const attachments = await Attachment.findAll({
@@ -472,7 +444,7 @@ export default abstract class ImportsProcessor<
     importInput: Record<string, ImportInput<any>[number]>;
     actorId: string;
   }): ProsemirrorDoc {
-    // special case when the doc content is empty.
+    // special case when the doc content is empty
     if (!content.content.length) {
       return content;
     }

server/queues/tasks/APIImportTask.ts

@@ -170,7 +170,7 @@ export default abstract class APIImportTask<
       await importTask.save({ transaction });
 
       const associatedImport = importTask.import;
-      associatedImport.documentCount += taskOutputWithReplacements.length;
+      associatedImport.documentCount += importTask.input.length;
       await associatedImport.saveWithCtx(
         createContext({
           user: associatedImport.createdBy,

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/ImportNotionTask.test.ts

@@ -0,0 +1,87 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import path from "path";
+import { FileOperation } from "@server/models";
+import { buildFileOperation } from "@server/test/factories";
+import ImportNotionTask from "./ImportNotionTask";
+
+describe("ImportNotionTask", () => {
+  it("should import successfully from a Markdown export", async () => {
+    const fileOperation = await buildFileOperation();
+    Object.defineProperty(fileOperation, "handle", {
+      get() {
+        return {
+          path: path.resolve(
+            __dirname,
+            "..",
+            "..",
+            "test",
+            "fixtures",
+            "notion-markdown.zip"
+          ),
+          cleanup: async () => {},
+        };
+      },
+    });
+    jest.spyOn(FileOperation, "findByPk").mockResolvedValue(fileOperation);
+
+    const props = {
+      fileOperationId: fileOperation.id,
+    };
+
+    const task = new ImportNotionTask();
+    const response = await task.perform(props);
+
+    expect(response.collections.size).toEqual(2);
+    expect(response.documents.size).toEqual(6);
+    expect(response.attachments.size).toEqual(1);
+
+    // Check that the image url was replaced in the text with a redirect
+    const attachments = Array.from(response.attachments.values());
+    const documents = Array.from(response.documents.values());
+    expect(documents.map((d) => d.text).join("")).toContain(
+      attachments[0].redirectUrl
+    );
+  });
+
+  it("should import successfully from a HTML export", async () => {
+    const fileOperation = await buildFileOperation();
+    Object.defineProperty(fileOperation, "handle", {
+      get() {
+        return {
+          path: path.resolve(
+            __dirname,
+            "..",
+            "..",
+            "test",
+            "fixtures",
+            "notion-html.zip"
+          ),
+          cleanup: async () => {},
+        };
+      },
+    });
+    jest.spyOn(FileOperation, "findByPk").mockResolvedValue(fileOperation);
+
+    const props = {
+      fileOperationId: fileOperation.id,
+    };
+
+    const task = new ImportNotionTask();
+    const response = await task.perform(props);
+
+    expect(response.collections.size).toEqual(2);
+    expect(response.documents.size).toEqual(6);
+    expect(response.attachments.size).toEqual(4);
+
+    // Check that the image url was replaced in the text with a redirect
+    const attachments = Array.from(response.attachments.values());
+    const attachment = attachments.find((att) =>
+      att.key.endsWith("Screen_Shot_2022-04-21_at_2.23.26_PM.png")
+    );
+
+    const documents = Array.from(response.documents.values());
+    expect(documents.map((d) => d.text).join("")).toContain(
+      attachment?.redirectUrl
+    );
+  });
+});

server/queues/tasks/ImportNotionTask.ts

@@ -0,0 +1,354 @@
+import path from "path";
+import fs from "fs-extra";
+import compact from "lodash/compact";
+import escapeRegExp from "lodash/escapeRegExp";
+import mime from "mime-types";
+import { v4 as uuidv4 } from "uuid";
+import documentImporter from "@server/commands/documentImporter";
+import { createContext } from "@server/context";
+import Logger from "@server/logging/Logger";
+import { FileOperation, User } from "@server/models";
+import { sequelize } from "@server/storage/database";
+import ImportHelper, { FileTreeNode } from "@server/utils/ImportHelper";
+import ImportTask, { StructuredImportData } from "./ImportTask";
+
+export default class ImportNotionTask extends ImportTask {
+  public async parseData(
+    dirPath: string,
+    fileOperation: FileOperation
+  ): Promise<StructuredImportData> {
+    const tree = await ImportHelper.toFileTree(dirPath);
+    if (!tree) {
+      throw new Error("Could not find valid content in zip file");
+    }
+
+    // New Notion exports have a single folder with the name of the export, we must skip this
+    // folder and go directly to the children.
+    let parsed;
+    if (
+      tree.children.length === 1 &&
+      tree.children[0].children.find((child) => child.title === "index")
+    ) {
+      parsed = await this.parseFileTree(
+        fileOperation,
+        tree.children[0].children.filter((child) => child.title !== "index")
+      );
+    } else {
+      parsed = await this.parseFileTree(fileOperation, tree.children);
+    }
+
+    if (parsed.documents.length === 0 && parsed.collections.length === 1) {
+      const collection = parsed.collections[0];
+      const collectionId = uuidv4();
+      if (collection.description) {
+        parsed.documents.push({
+          title: collection.name,
+          icon: collection.icon,
+          color: collection.color,
+          path: "",
+          text: String(collection.description),
+          id: collection.id,
+          externalId: collection.externalId,
+          mimeType: "text/html",
+          collectionId,
+        });
+      }
+
+      collection.name = "Notion";
+      collection.icon = undefined;
+      collection.color = undefined;
+      collection.externalId = undefined;
+      collection.description = undefined;
+      collection.id = collectionId;
+    }
+
+    return parsed;
+  }
+
+  /**
+   * Converts the file structure from zipAsFileTree into documents,
+   * collections, and attachments.
+   *
+   * @param fileOperation The file operation
+   * @param tree An array of FileTreeNode representing root files in the zip
+   * @returns A StructuredImportData object
+   */
+  private async parseFileTree(
+    fileOperation: FileOperation,
+    tree: FileTreeNode[]
+  ): Promise<StructuredImportData> {
+    const user = await User.findByPk(fileOperation.userId, {
+      rejectOnEmpty: true,
+    });
+
+    const output: StructuredImportData = {
+      collections: [],
+      documents: [],
+      attachments: [],
+    };
+
+    const parseNodeChildren = async (
+      children: FileTreeNode[],
+      collectionId: string,
+      parentDocumentId?: string
+    ): Promise<void> => {
+      await Promise.all(
+        children.map(async (child) => {
+          // Ignore the CSV's for databases upfront
+          if (child.path.endsWith(".csv")) {
+            return;
+          }
+
+          const id = uuidv4();
+          const match = child.title.match(this.NotionUUIDRegex);
+          const name = child.title.replace(this.NotionUUIDRegex, "");
+          const externalId = match ? match[0].trim() : undefined;
+
+          // If it's not a text file we're going to treat it as an attachment.
+          const mimeType = mime.lookup(child.name);
+          const isDocument =
+            mimeType === "text/markdown" ||
+            mimeType === "text/plain" ||
+            mimeType === "text/html";
+
+          // If it's not a document and not a folder, treat it as an attachment
+          if (!isDocument && mimeType) {
+            output.attachments.push({
+              id,
+              name: child.name,
+              path: child.path,
+              mimeType,
+              buffer: () => fs.readFile(child.path),
+              externalId,
+            });
+            return;
+          }
+
+          Logger.debug("task", `Processing ${name} as ${mimeType}`);
+
+          const { title, icon, text } = await sequelize.transaction(
+            async (transaction) =>
+              documentImporter({
+                mimeType: mimeType || "text/markdown",
+                fileName: name,
+                content:
+                  child.children.length > 0
+                    ? ""
+                    : await fs.readFile(child.path, "utf8"),
+                user,
+                ctx: createContext({ user, transaction }),
+              })
+          );
+
+          const existingDocumentIndex = output.documents.findIndex(
+            (doc) => doc.externalId === externalId
+          );
+
+          const existingDocument = output.documents[existingDocumentIndex];
+
+          // If there is an existing document with the same externalId that means
+          // we've already parsed either a folder or a file referencing the same
+          // document, as such we should merge.
+          if (existingDocument) {
+            if (existingDocument.text === "") {
+              output.documents[existingDocumentIndex].text = text;
+            }
+
+            await parseNodeChildren(
+              child.children,
+              collectionId,
+              existingDocument.id
+            );
+          } else {
+            output.documents.push({
+              id,
+              title,
+              icon,
+              text,
+              collectionId,
+              parentDocumentId,
+              path: child.path,
+              mimeType: mimeType || "text/markdown",
+              externalId,
+            });
+            await parseNodeChildren(child.children, collectionId, id);
+          }
+        })
+      );
+    };
+
+    const replaceInternalLinksAndImages = (text: string) => {
+      // Find if there are any images in this document
+      const imagesInText = this.parseImages(text);
+
+      for (const image of imagesInText) {
+        const name = path.basename(image.src);
+        const attachment = output.attachments.find(
+          (att) =>
+            att.path.endsWith(image.src) ||
+            encodeURI(att.path).endsWith(image.src)
+        );
+
+        if (!attachment) {
+          if (!image.src.startsWith("http")) {
+            Logger.info(
+              "task",
+              `Could not find referenced attachment with name ${name} and src ${image.src}`
+            );
+          }
+        } else {
+          text = text.replace(
+            new RegExp(escapeRegExp(image.src), "g"),
+            `<<${attachment.id}>>`
+          );
+        }
+      }
+
+      // With Notion's HTML import, images sometimes come wrapped in anchor tags
+      // This isn't supported in Outline's editor, so we need to strip them.
+      text = text.replace(/\[!\[([^[]+)]/g, "![]");
+
+      // Find if there are any links in this document pointing to other documents
+      const internalLinksInText = this.parseInternalLinks(text);
+
+      // For each link update to the standardized format of <<documentId>>
+      // instead of a relative or absolute URL within the original zip file.
+      for (const link of internalLinksInText) {
+        const doc = output.documents.find(
+          (doc) => doc.externalId === link.externalId
+        );
+
+        if (!doc) {
+          Logger.info(
+            "task",
+            `Could not find referenced document with externalId ${link.externalId}`
+          );
+        } else {
+          text = text.replace(link.href, `<<${doc.id}>>`);
+        }
+      }
+
+      return text;
+    };
+
+    // All nodes in the root level should become collections
+    for (const node of tree) {
+      const match = node.title.match(this.NotionUUIDRegex);
+      const name = node.title.replace(this.NotionUUIDRegex, "");
+      const externalId = match ? match[0].trim() : undefined;
+      const mimeType = mime.lookup(node.name);
+
+      const existingCollectionIndex = output.collections.findIndex(
+        (collection) => collection.externalId === externalId
+      );
+      const existingCollection = output.collections[existingCollectionIndex];
+      const collectionId = existingCollection?.id || uuidv4();
+      let description;
+
+      // Root level docs become the descriptions of collections
+      if (
+        mimeType === "text/markdown" ||
+        mimeType === "text/plain" ||
+        mimeType === "text/html"
+      ) {
+        const { text } = await sequelize.transaction(async (transaction) =>
+          documentImporter({
+            mimeType,
+            fileName: name,
+            content: await fs.readFile(node.path, "utf8"),
+            user,
+            ctx: createContext({ user, transaction }),
+          })
+        );
+
+        description = text;
+      } else if (node.children.length > 0) {
+        await parseNodeChildren(node.children, collectionId);
+      } else {
+        Logger.debug("task", `Unhandled file in zip: ${node.path}`, {
+          fileOperationId: fileOperation.id,
+        });
+        continue;
+      }
+
+      if (existingCollectionIndex !== -1) {
+        if (description) {
+          output.collections[existingCollectionIndex].description = description;
+        }
+      } else {
+        output.collections.push({
+          id: collectionId,
+          name,
+          description,
+          externalId,
+        });
+      }
+    }
+
+    for (const document of output.documents) {
+      document.text = replaceInternalLinksAndImages(document.text);
+    }
+
+    for (const collection of output.collections) {
+      if (typeof collection.description === "string") {
+        collection.description = replaceInternalLinksAndImages(
+          collection.description
+        );
+      }
+    }
+
+    return output;
+  }
+
+  /**
+   * Extracts internal links from a markdown document, taking into account the
+   * externalId of the document, which is part of the link title.
+   *
+   * @param text The markdown text to parse
+   * @returns An array of internal links
+   */
+  private parseInternalLinks(
+    text: string
+  ): { title: string; href: string; externalId: string }[] {
+    return compact(
+      [...text.matchAll(this.NotionLinkRegex)].map((match) => ({
+        title: match[1],
+        href: match[2],
+        externalId: match[3],
+      }))
+    );
+  }
+
+  /**
+   * Extracts images from the markdown document
+   *
+   * @param text The markdown text to parse
+   * @returns An array of internal links
+   */
+  private parseImages(text: string): { alt: string; src: string }[] {
+    return compact(
+      [...text.matchAll(this.ImageRegex)].map((match) => ({
+        alt: match[1],
+        src: match[2],
+      }))
+    );
+  }
+
+  /**
+   * Regex to find markdown images of all types
+   */
+  private ImageRegex =
+    /!\[(?<alt>[^\][]*?)]\((?<filename>[^\][]*?)(?=“|\))“?(?<title>[^\][”]+)?”?\)/g;
+
+  /**
+   * Regex to find markdown links containing ID's that look like UUID's with the
+   * "-"'s removed, Notion's externalId format.
+   */
+  private NotionLinkRegex = /\[([^[]+)]\((.*?([0-9a-fA-F]{32})\..*?)\)/g;
+
+  /**
+   * Regex to find Notion document UUID's in the title of a document.
+   */
+  private NotionUUIDRegex =
+    /\s([0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}|[0-9a-fA-F]{32})$/;
+}

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));

server/routes/api/collections/collections.test.ts

@@ -1327,32 +1327,6 @@ describe("#collections.create", () => {
     expect(body.policies[0].abilities.read).toBeTruthy();
   });
 
-  it("should ensure unique index across the team", async () => {
-    const team = await buildTeam();
-    const [adminA, adminB] = await Promise.all([
-      buildAdmin({ teamId: team.id }),
-      buildAdmin({ teamId: team.id }),
-    ]);
-
-    const resA = await server.post("/api/collections.create", {
-      body: {
-        token: adminA.getJwtToken(),
-        name: "Test A",
-      },
-    });
-    const resB = await server.post("/api/collections.create", {
-      body: {
-        token: adminB.getJwtToken(),
-        name: "Test B",
-      },
-    });
-    const [bodyA, bodyB] = await Promise.all([resA.json(), resB.json()]);
-
-    expect(resA.status).toEqual(200);
-    expect(resB.status).toEqual(200);
-    expect(bodyA.data.index).not.toEqual(bodyB.data.index);
-  });
-
   it("if index collision, should updated index of other collection", async () => {
     const user = await buildUser();
     const createdCollectionAResponse = await server.post(

server/routes/api/collections/collections.ts

@@ -1,3 +1,4 @@
+import fractionalIndex from "fractional-index";
 import invariant from "invariant";
 import Router from "koa-router";
 import { Sequelize, Op, WhereOptions } from "sequelize";
@@ -41,6 +42,7 @@ import {
 import { APIContext } from "@server/types";
 import { RateLimiterStrategy } from "@server/utils/RateLimiter";
 import { collectionIndexing } from "@server/utils/indexing";
+import removeIndexCollision from "@server/utils/removeIndexCollision";
 import pagination from "../middlewares/pagination";
 import * as T from "./schema";
 
@@ -53,21 +55,23 @@ router.post(
   transaction(),
   async (ctx: APIContext<T.CollectionsCreateReq>) => {
     const { transaction } = ctx.state;
-    const {
-      name,
-      color,
-      description,
-      data,
-      permission,
-      sharing,
-      icon,
-      sort,
-      index,
-    } = ctx.input.body;
+    const { name, color, description, data, permission, sharing, icon, sort } =
+      ctx.input.body;
+    let { index } = ctx.input.body;
 
     const { user } = ctx.state.auth;
     authorize(user, "createCollection", user.team);
 
+    if (index) {
+      index = await removeIndexCollision(user.teamId, index, { transaction });
+    } else {
+      const first = await Collection.findFirstCollectionForUser(user, {
+        attributes: ["id", "index"],
+        transaction,
+      });
+      index = fractionalIndex(null, first ? first.index : null);
+    }
+
     const collection = Collection.build({
       name,
       content: data,
@@ -597,7 +601,6 @@ router.post(
           createdById: user.id,
         },
         transaction,
-        hooks: false,
       });
     }
 
@@ -956,16 +959,18 @@ router.post(
   transaction(),
   async (ctx: APIContext<T.CollectionsMoveReq>) => {
     const { transaction } = ctx.state;
-    const { id, index } = ctx.input.body;
+    const { id } = ctx.input.body;
+    let { index } = ctx.input.body;
     const { user } = ctx.state.auth;
 
-    let collection = await Collection.findByPk(id, {
+    const collection = await Collection.findByPk(id, {
       transaction,
       lock: transaction.LOCK.UPDATE,
     });
     authorize(user, "move", collection);
 
-    collection = await collection.update(
+    index = await removeIndexCollision(user.teamId, index, { transaction });
+    await collection.update(
       {
         index,
       },
@@ -977,14 +982,14 @@ router.post(
       name: "collections.move",
       collectionId: collection.id,
       data: {
-        index: collection.index,
+        index,
       },
     });
 
     ctx.body = {
       success: true,
       data: {
-        index: collection.index,
+        index,
       },
     };
   }

server/routes/api/notifications/notifications.test.ts

@@ -2,7 +2,6 @@ import queryString from "query-string";
 import { v4 as uuidv4 } from "uuid";
 import { randomElement } from "@shared/random";
 import { NotificationEventType } from "@shared/types";
-import NotificationSettingsHelper from "@server/models/helpers/NotificationSettingsHelper";
 import {
   buildCollection,
   buildDocument,
@@ -698,40 +697,3 @@ describe("#notifications.update_all", () => {
     expect(body.data.total).toBe(2);
   });
 });
-
-describe("#notifications.unsubscribe", () => {
-  it("should allow unsubscribe with valid token", async () => {
-    const user = await buildUser();
-    const token = NotificationSettingsHelper.unsubscribeToken(
-      user.id,
-      NotificationEventType.UpdateDocument
-    );
-
-    const res = await server.get(
-      `/api/notifications.unsubscribe?userId=${user.id}&token=${token}&eventType=documents.update&follow=true`,
-      {
-        redirect: "manual",
-      }
-    );
-    expect(res.status).toBe(302);
-    expect(res.headers.get("location")).toContain(
-      "/settings/notifications?success"
-    );
-
-    const events = (await user.reload()).notificationSettings;
-    expect(events).not.toContain("documents.update");
-  });
-
-  it("should not allow unsubscribe with invalid token", async () => {
-    const user = await buildUser();
-
-    const res = await server.get(
-      `/api/notifications.unsubscribe?userId=${user.id}&token=invalid-token&eventType=documents.update&follow=true`,
-      {
-        redirect: "manual",
-      }
-    );
-    expect(res.status).toBe(302);
-    expect(res.headers.get("location")).toContain("?notice=invalid-auth");
-  });
-});

server/routes/api/notifications/notifications.ts

@@ -53,7 +53,7 @@ const handleUnsubscribe = async (
   });
 
   user.setNotificationEventType(eventType, false);
-  await user.save({ transaction });
+  await user.save();
   ctx.redirect(`${user.team.url}/settings/notifications?success`);
 };
 

server/utils/avatars.test.ts

@@ -0,0 +1,9 @@
+import { generateAvatarUrl } from "./avatars";
+
+it("should return clearbit url if available", async () => {
+  const url = await generateAvatarUrl({
+    id: "google",
+    domain: "google.com",
+  });
+  expect(url).toBe("https://logo.clearbit.com/google.com");
+});

server/utils/avatars.ts

@@ -0,0 +1,28 @@
+import crypto from "crypto";
+import fetch from "./fetch";
+
+export async function generateAvatarUrl({
+  id,
+  domain,
+}: {
+  id: string;
+  domain?: string;
+}) {
+  // attempt to get logo from Clearbit API. If one doesn't exist then
+  // fall back to using tiley to generate a placeholder logo
+  const hash = crypto.createHash("sha256");
+  hash.update(id);
+  let cbResponse, cbUrl;
+
+  if (domain) {
+    cbUrl = `https://logo.clearbit.com/${domain}`;
+
+    try {
+      cbResponse = await fetch(cbUrl);
+    } catch (err) {
+      // okay
+    }
+  }
+
+  return cbUrl && cbResponse && cbResponse.status === 200 ? cbUrl : null;
+}

server/utils/removeIndexCollision.ts

@@ -1,5 +1,5 @@
 import fractionalIndex from "fractional-index";
-import { Sequelize, type FindOptions } from "sequelize";
+import { Op, Sequelize, type FindOptions } from "sequelize";
 import Collection from "@server/models/Collection";
 
 /**
@@ -31,7 +31,9 @@ export default async function removeIndexCollision(
     where: {
       teamId,
       deletedAt: null,
-      index: Sequelize.literal(`"collection"."index" collate "C" > '${index}'`),
+      index: {
+        [Op.gt]: index,
+      },
     },
     attributes: ["id", "index"],
     limit: 1,

server/validation.ts

@@ -232,7 +232,7 @@ export class ValidateDocumentId {
 export class ValidateIndex {
   public static regex = new RegExp("^[\x20-\x7E]+$");
   public static message = "Must be between x20 to x7E ASCII";
-  public static maxLength = 256;
+  public static maxLength = 100;
 }
 
 export class ValidateURL {

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/components/Styles.ts

@@ -313,10 +313,6 @@ width: 100%;
     background: ${props.theme.mentionHoverBackground};
   }
 
-  &[data-type="user"] {
-    gap: 0;
-  }
-
   &.mention-user::before {
     content: "@";
   }

shared/editor/lib/table.ts

@@ -28,10 +28,9 @@ export function getCellAttrs(dom: HTMLElement | string): Attrs {
   const widthAttr = dom.getAttribute("data-colwidth");
   const widths =
     widthAttr && /^\d+(,\d+)*$/.test(widthAttr)
-      ? widthAttr.split(",").map(Number)
+      ? widthAttr.split(",").map((s) => Number(s))
       : null;
   const colspan = Number(dom.getAttribute("colspan") || 1);
-
   return {
     colspan,
     rowspan: Number(dom.getAttribute("rowspan") || 1),
@@ -64,11 +63,10 @@ export function setCellAttrs(node: Node): Attrs {
   }
   if (node.attrs.colwidth) {
     if (isBrowser) {
-      attrs["data-colwidth"] = node.attrs.colwidth.map(parseInt).join(",");
+      attrs["data-colwidth"] = node.attrs.colwidth.join(",");
     } else {
       attrs.style =
-        (attrs.style ?? "") +
-        `min-width: ${parseInt(node.attrs.colwidth[0])}px;`;
+        (attrs.style ?? "") + `min-width: ${node.attrs.colwidth}px;`;
     }
   }
 

shared/editor/marks/Code.ts

@@ -21,10 +21,9 @@ export default class Code extends Mark {
 
   get schema(): MarkSpec {
     return {
-      excludes: "mention placeholder highlight",
+      excludes: "mention placeholder highlight em strong",
       parseDOM: [{ tag: "code", preserveWhitespace: true }],
       toDOM: () => ["code", { class: "inline", spellCheck: "false" }],
-      code: true,
     };
   }
 

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,
     };
   }
 

shared/editor/queries/isInCode.ts

@@ -7,8 +7,6 @@ type Options = {
   onlyBlock?: boolean;
   /** Only check if the selection is inside a code mark. */
   onlyMark?: boolean;
-  /** If true then code must contain entire selection */
-  inclusive?: boolean;
 };
 
 /**
@@ -22,29 +20,17 @@ export function isInCode(state: EditorState, options?: Options): boolean {
   const { nodes, marks } = state.schema;
 
   if (!options?.onlyMark) {
-    if (
-      nodes.code_block &&
-      isNodeActive(nodes.code_block, undefined, {
-        inclusive: options?.inclusive,
-      })(state)
-    ) {
+    if (nodes.code_block && isNodeActive(nodes.code_block)(state)) {
       return true;
     }
-    if (
-      nodes.code_fence &&
-      isNodeActive(nodes.code_fence, undefined, {
-        inclusive: options?.inclusive,
-      })(state)
-    ) {
+    if (nodes.code_fence && isNodeActive(nodes.code_fence)(state)) {
       return true;
     }
   }
 
   if (!options?.onlyBlock) {
     if (marks.code_inline) {
-      return isMarkActive(marks.code_inline, undefined, {
-        inclusive: options?.inclusive,
-      })(state);
+      return isMarkActive(marks.code_inline)(state);
     }
   }
 

shared/editor/queries/isMarkActive.ts

@@ -6,8 +6,6 @@ import { getMarksBetween } from "./getMarksBetween";
 type Options = {
   /** Only return match if the range and attrs is exact */
   exact?: boolean;
-  /** If true then mark must contain entire selection */
-  inclusive?: boolean;
 };
 
 /**
@@ -42,8 +40,7 @@ export const isMarkActive =
             Object.keys(attrs).every(
               (key) => mark.attrs[key] === attrs[key]
             )) &&
-          (!options?.exact || (start === from && end === to)) &&
-          (!options?.inclusive || (start <= from && end >= to))
+          (!options?.exact || (start === from && end === to))
       );
     }
 

shared/editor/queries/isNodeActive.ts

@@ -3,55 +3,31 @@ import { EditorState } from "prosemirror-state";
 import { Primitive } from "utility-types";
 import { findParentNode } from "./findParentNode";
 
-type Options = {
-  /** Only return match if the range and attrs is exact */
-  exact?: boolean;
-  /** If true then node must contain entire selection */
-  inclusive?: boolean;
-};
-
 /**
  * Checks if a node is active in the current selection or not.
  *
  * @param type The node type to check.
  * @param attrs The attributes to check.
- * @param options The options to use.
  * @returns A function that checks if a node is active in the current selection or not.
  */
 export const isNodeActive =
-  (type: NodeType, attrs?: Record<string, Primitive>, options?: Options) =>
-  (state: EditorState): boolean => {
+  (type: NodeType, attrs: Record<string, Primitive> = {}) =>
+  (state: EditorState) => {
     if (!type) {
       return false;
     }
 
-    const { from, to } = state.selection;
-    const nodeWithPos = findParentNode(
-      (node) =>
-        node.type === type &&
-        (!attrs ||
-          Object.keys(attrs).every((key) => node.attrs[key] === attrs[key]))
-    )(state.selection);
+    const nodeAfter = state.selection.$from.nodeAfter;
+    let node = nodeAfter?.type === type ? nodeAfter : undefined;
 
-    if (!nodeWithPos) {
-      return false;
+    if (!node) {
+      const parent = findParentNode((n) => n.type === type)(state.selection);
+      node = parent?.node;
     }
 
-    if (options?.inclusive) {
-      // Check if the node's position contains the entire selection
-      return (
-        nodeWithPos.pos <= from &&
-        nodeWithPos.pos + nodeWithPos.node.nodeSize >= to
-      );
+    if (!Object.keys(attrs).length || !node) {
+      return !!node;
     }
 
-    if (options?.exact) {
-      // Check if node's range exactly matches selection
-      return (
-        nodeWithPos.pos === from &&
-        nodeWithPos.pos + nodeWithPos.node.nodeSize === to
-      );
-    }
-
-    return true;
+    return node.hasMarkup(type, { ...node.attrs, ...attrs });
   };

shared/hooks/useComponentSize.ts

@@ -1,5 +1,16 @@
 import { useState, useLayoutEffect } from "react";
 
+const defaultRect = {
+  top: 0,
+  left: 0,
+  bottom: 0,
+  right: 0,
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+};
+
 /**
  * A hook that returns the size of an element or ref.
  *
@@ -8,11 +19,19 @@ import { useState, useLayoutEffect } from "react";
  */
 export function useComponentSize(
   input: HTMLElement | null | React.RefObject<HTMLElement | null>
-) {
+): DOMRect | typeof defaultRect {
   const element = input instanceof HTMLElement ? input : input?.current;
-  const [size, setSize] = useState<DOMRect | undefined>(
-    () => element?.getBoundingClientRect() || new DOMRect()
-  );
+  const [size, setSize] = useState(() => element?.getBoundingClientRect());
+
+  useLayoutEffect(() => {
+    const sizeObserver = new ResizeObserver(() => {
+      element?.dispatchEvent(new CustomEvent("resize"));
+    });
+    if (element) {
+      sizeObserver.observe(element);
+    }
+    return () => sizeObserver.disconnect();
+  }, [element]);
 
   useLayoutEffect(() => {
     const handleResize = () => {
@@ -36,7 +55,6 @@ export function useComponentSize(
     window.addEventListener("click", handleResize);
     window.addEventListener("resize", handleResize);
     element?.addEventListener("resize", handleResize);
-    handleResize();
 
     return () => {
       window.removeEventListener("click", handleResize);
@@ -45,15 +63,5 @@ export function useComponentSize(
     };
   });
 
-  useLayoutEffect(() => {
-    const sizeObserver = new ResizeObserver(() => {
-      element?.dispatchEvent(new CustomEvent("resize"));
-    });
-    if (element) {
-      sizeObserver.observe(element);
-    }
-    return () => sizeObserver.disconnect();
-  }, [element]);
-
-  return size ?? new DOMRect();
+  return size ?? defaultRect;
 }

shared/i18n/locales/en_US/translation.json

@@ -903,6 +903,9 @@
   "{{ count }} document imported_plural": "{{ count }} documents imported",
   "You can import a zip file that was previously exported from an Outline installation – collections, documents, and images will be imported. In Outline, open <em>Export</em> in the Settings sidebar and click on <em>Export Data</em>.": "You can import a zip file that was previously exported from an Outline installation – collections, documents, and images will be imported. In Outline, open <em>Export</em> in the Settings sidebar and click on <em>Export Data</em>.",
   "Drag and drop the zip file from the Markdown export option in {{appName}}, or click to upload": "Drag and drop the zip file from the Markdown export option in {{appName}}, or click to upload",
+  "Where do I find the file?": "Where do I find the file?",
+  "In Notion, click <em>Settings & Members</em> in the left sidebar and open Settings. Look for the Export section, and click <em>Export all workspace content</em>. Choose <em>HTML</em> as the format for the best data compatability.": "In Notion, click <em>Settings & Members</em> in the left sidebar and open Settings. Look for the Export section, and click <em>Export all workspace content</em>. Choose <em>HTML</em> as the format for the best data compatability.",
+  "Drag and drop the zip file from Notion's HTML export option, or click to upload": "Drag and drop the zip file from Notion's HTML export option, or click to upload",
   "Last active": "Last active",
   "Guest": "Guest",
   "Shared by": "Shared by",