translations

* Manage collection subscriptions when user (or) group is removed from a collection

* rename collection task

* rename document task

* remove unnecessary actor filter

app/models/Import.ts

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

app/scenes/Settings/components/ImportListItem.tsx

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

app/scenes/Settings/components/ImportNotionDialog.tsx

@@ -1,36 +0,0 @@
-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;

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

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

server/models/Import.ts

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

server/models/ImportTask.ts

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

server/presenters/import.ts

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

server/queues/processors/DocumentSubscriptionProcessor.ts

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

server/queues/processors/FileOperationCreatedProcessor.ts

@@ -6,7 +6,6 @@ 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 {
@@ -25,11 +24,6 @@ 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

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

server/queues/tasks/APIImportTask.ts

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

server/queues/tasks/CollectionSubscriptionRemoveUserTask.ts

@@ -0,0 +1,52 @@
+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/DocumentSubscriptionRemoveUserTask.ts

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

server/queues/tasks/ErrorTimedOutImportsTask.ts

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

server/queues/tasks/ImportNotionTask.test.ts

@@ -1,87 +0,0 @@
-/* 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

@@ -1,354 +0,0 @@
-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})$/;
-}

shared/components/EventBoundary.tsx

@@ -10,6 +10,10 @@ 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,14 +5,26 @@ 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,6 +11,11 @@ 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/marks/Code.ts

@@ -99,7 +99,6 @@ export default class Code extends Mark {
               return false;
             }
 
-            // Check if we're pasting inside backticks
             const start = from - 1;
             const end = to + 1;
             if (
@@ -119,69 +118,6 @@ export default class Code extends Mark {
               return true;
             }
 
-            // Check if we're pasting over an existing inline code block
-            if (isInCode(state, { onlyMark: true })) {
-              // Get the range of the current code mark
-              const marks = state.doc.resolve(from).marks();
-              const codeMark = marks.find(
-                (mark) => mark.type === state.schema.marks.code_inline
-              );
-              
-              if (codeMark) {
-                // Find the start and end of the code mark
-                let codeStart = from;
-                let codeEnd = to;
-                
-                // Find the start of the code mark
-                for (let i = from; i > 0; i--) {
-                  const resolvedPos = state.doc.resolve(i);
-                  const marksAtPos = resolvedPos.marks();
-                  const hasCodeMark = marksAtPos.some(
-                    (mark) => mark.type === state.schema.marks.code_inline
-                  );
-                  
-                  if (!hasCodeMark) {
-                    codeStart = i + 1;
-                    break;
-                  }
-                  
-                  if (i === 1) {
-                    codeStart = 1;
-                  }
-                }
-                
-                // Find the end of the code mark
-                for (let i = to; i < state.doc.nodeSize - 2; i++) {
-                  const resolvedPos = state.doc.resolve(i);
-                  const marksAtPos = resolvedPos.marks();
-                  const hasCodeMark = marksAtPos.some(
-                    (mark) => mark.type === state.schema.marks.code_inline
-                  );
-                  
-                  if (!hasCodeMark) {
-                    codeEnd = i;
-                    break;
-                  }
-                  
-                  if (i === state.doc.nodeSize - 3) {
-                    codeEnd = state.doc.nodeSize - 2;
-                  }
-                }
-                
-                // Replace the content within the code mark
-                view.dispatch(
-                  state.tr
-                    .replaceRange(from, to, slice)
-                    .addMark(
-                      from,
-                      from + slice.size,
-                      state.schema.marks.code_inline.create()
-                    )
-                );
-                return true;
-              }
-            }
-
             return false;
           },
 

shared/i18n/locales/en_US/translation.json

@@ -903,9 +903,6 @@
   "{{ 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",