feat: copy page to different space (#1118)

* Add copy page to space endpoint
* copy storage function
* copy function
* feat: copy attachments too
* Copy page - WIP
* fix type
* sync
* cleanup

apps/server/src/common/helpers/prosemirror/utils.ts

@@ -1,7 +1,12 @@
 import { Node } from '@tiptap/pm/model';
-import { jsonToNode } from '../../../collaboration/collaboration.util';
+import {
+  jsonToNode,
+  tiptapExtensions,
+} from '../../../collaboration/collaboration.util';
 import { validate as isValidUUID } from 'uuid';
 import { Transform } from '@tiptap/pm/transform';
+import { TiptapTransformer } from '@hocuspocus/transformer';
+import * as Y from 'yjs';
 
 export interface MentionNode {
   id: string;
@@ -59,7 +64,6 @@ export function extractPageMentions(mentionList: MentionNode[]): MentionNode[] {
   return pageMentionList as MentionNode[];
 }
 
-
 export function getProsemirrorContent(content: any) {
   return (
     content ?? {
@@ -107,4 +111,19 @@ export function removeMarkTypeFromDoc(doc: Node, markName: string): Node {
 
   const tr = new Transform(doc).removeMark(0, doc.content.size, markType);
   return tr.doc;
-}
+}
+
+export function createYdocFromJson(prosemirrorJson: any): Buffer | null {
+  if (prosemirrorJson) {
+    const ydoc = TiptapTransformer.toYdoc(
+      prosemirrorJson,
+      'default',
+      tiptapExtensions,
+    );
+
+    Y.encodeStateAsUpdate(ydoc);
+
+    return Buffer.from(Y.encodeStateAsUpdate(ydoc));
+  }
+  return null;
+}

apps/server/src/core/page/dto/copy-page.dto.ts

@@ -0,0 +1,24 @@
+import { IsString, IsNotEmpty } from 'class-validator';
+
+export class CopyPageToSpaceDto {
+  @IsNotEmpty()
+  @IsString()
+  pageId: string;
+
+  @IsNotEmpty()
+  @IsString()
+  spaceId: string;
+}
+
+export type CopyPageMapEntry = {
+  newPageId: string;
+  newSlugId: string;
+  oldSlugId: string;
+};
+
+export type ICopyPageAttachment = {
+  newPageId: string,
+  oldPageId: string,
+  oldAttachmentId: string,
+  newAttachmentId: string,
+};

apps/server/src/core/page/dto/move-page.dto.ts

@@ -1,4 +1,10 @@
-import { IsString, IsOptional, MinLength, MaxLength } from 'class-validator';
+import {
+  IsString,
+  IsOptional,
+  MinLength,
+  MaxLength,
+  IsNotEmpty,
+} from 'class-validator';
 
 export class MovePageDto {
   @IsString()
@@ -15,9 +21,11 @@ export class MovePageDto {
 }
 
 export class MovePageToSpaceDto {
+  @IsNotEmpty()
   @IsString()
   pageId: string;
 
+  @IsNotEmpty()
   @IsString()
   spaceId: string;
 }

apps/server/src/core/page/page.controller.ts

@@ -28,6 +28,7 @@ import {
 import SpaceAbilityFactory from '../casl/abilities/space-ability.factory';
 import { PageRepo } from '@docmost/db/repos/page/page.repo';
 import { RecentPageDto } from './dto/recent-page.dto';
+import { CopyPageToSpaceDto } from './dto/copy-page.dto';
 
 @UseGuards(JwtAuthGuard)
 @Controller('pages')
@@ -237,6 +238,36 @@ export class PageController {
     return this.pageService.movePageToSpace(movedPage, dto.spaceId);
   }
 
+  @HttpCode(HttpStatus.OK)
+  @Post('copy-to-space')
+  async copyPageToSpace(
+    @Body() dto: CopyPageToSpaceDto,
+    @AuthUser() user: User,
+  ) {
+    const copiedPage = await this.pageRepo.findById(dto.pageId);
+    if (!copiedPage) {
+      throw new NotFoundException('Page to copy not found');
+    }
+    if (copiedPage.spaceId === dto.spaceId) {
+      throw new BadRequestException('Page is already in this space');
+    }
+
+    const abilities = await Promise.all([
+      this.spaceAbility.createForUser(user, copiedPage.spaceId),
+      this.spaceAbility.createForUser(user, dto.spaceId),
+    ]);
+
+    if (
+      abilities.some((ability) =>
+        ability.cannot(SpaceCaslAction.Edit, SpaceCaslSubject.Page),
+      )
+    ) {
+      throw new ForbiddenException();
+    }
+
+    return this.pageService.copyPageToSpace(copiedPage, dto.spaceId, user);
+  }
+
   @HttpCode(HttpStatus.OK)
   @Post('move')
   async movePage(@Body() dto: MovePageDto, @AuthUser() user: User) {

apps/server/src/core/page/page.module.ts

@@ -2,10 +2,12 @@ import { Module } from '@nestjs/common';
 import { PageService } from './services/page.service';
 import { PageController } from './page.controller';
 import { PageHistoryService } from './services/page-history.service';
+import { StorageModule } from '../../integrations/storage/storage.module';
 
 @Module({
   controllers: [PageController],
   providers: [PageService, PageHistoryService],
   exports: [PageService, PageHistoryService],
+  imports: [StorageModule]
 })
 export class PageModule {}

apps/server/src/core/page/services/page.service.ts

@@ -1,12 +1,13 @@
 import {
   BadRequestException,
   Injectable,
+  Logger,
   NotFoundException,
 } from '@nestjs/common';
 import { CreatePageDto } from '../dto/create-page.dto';
 import { UpdatePageDto } from '../dto/update-page.dto';
 import { PageRepo } from '@docmost/db/repos/page/page.repo';
-import { Page } from '@docmost/db/types/entity.types';
+import { InsertablePage, Page, User } from '@docmost/db/types/entity.types';
 import { PaginationOptions } from '@docmost/db/pagination/pagination-options';
 import {
   executeWithPagination,
@@ -21,13 +22,28 @@ import { DB } from '@docmost/db/types/db';
 import { generateSlugId } from '../../../common/helpers';
 import { executeTx } from '@docmost/db/utils';
 import { AttachmentRepo } from '@docmost/db/repos/attachment/attachment.repo';
+import { v7 as uuid7 } from 'uuid';
+import {
+  createYdocFromJson,
+  getAttachmentIds,
+  getProsemirrorContent,
+  isAttachmentNode,
+  removeMarkTypeFromDoc,
+} from '../../../common/helpers/prosemirror/utils';
+import { jsonToNode, jsonToText } from 'src/collaboration/collaboration.util';
+import { CopyPageMapEntry, ICopyPageAttachment } from '../dto/copy-page.dto';
+import { Node as PMNode } from '@tiptap/pm/model';
+import { StorageService } from '../../../integrations/storage/storage.service';
 
 @Injectable()
 export class PageService {
+  private readonly logger = new Logger(PageService.name);
+
   constructor(
     private pageRepo: PageRepo,
     private attachmentRepo: AttachmentRepo,
     @InjectKysely() private readonly db: KyselyDB,
+    private readonly storageService: StorageService,
   ) {}
 
   async findById(
@@ -242,6 +258,154 @@ export class PageService {
     });
   }
 
+  async copyPageToSpace(rootPage: Page, spaceId: string, authUser: User) {
+    //TODO:
+    // i. maintain internal links within copied pages
+
+    const nextPosition = await this.nextPagePosition(spaceId);
+
+    const pages = await this.pageRepo.getPageAndDescendants(rootPage.id, {
+      includeContent: true,
+    });
+
+    const pageMap = new Map<string, CopyPageMapEntry>();
+    pages.forEach((page) => {
+      pageMap.set(page.id, {
+        newPageId: uuid7(),
+        newSlugId: generateSlugId(),
+        oldSlugId: page.slugId,
+      });
+    });
+
+    const attachmentMap = new Map<string, ICopyPageAttachment>();
+
+    const insertablePages: InsertablePage[] = await Promise.all(
+      pages.map(async (page) => {
+        const pageContent = getProsemirrorContent(page.content);
+        const pageFromMap = pageMap.get(page.id);
+
+        const doc = jsonToNode(pageContent);
+        const prosemirrorDoc = removeMarkTypeFromDoc(doc, 'comment');
+
+        const attachmentIds = getAttachmentIds(prosemirrorDoc.toJSON());
+
+        if (attachmentIds.length > 0) {
+          attachmentIds.forEach((attachmentId: string) => {
+            const newPageId = pageFromMap.newPageId;
+            const newAttachmentId = uuid7();
+            attachmentMap.set(attachmentId, {
+              newPageId: newPageId,
+              oldPageId: page.id,
+              oldAttachmentId: attachmentId,
+              newAttachmentId: newAttachmentId,
+            });
+
+            prosemirrorDoc.descendants((node: PMNode) => {
+              if (isAttachmentNode(node.type.name)) {
+                if (node.attrs.attachmentId === attachmentId) {
+                  //@ts-ignore
+                  node.attrs.attachmentId = newAttachmentId;
+
+                  if (node.attrs.src) {
+                    //@ts-ignore
+                    node.attrs.src = node.attrs.src.replace(
+                      attachmentId,
+                      newAttachmentId,
+                    );
+                  }
+                  if (node.attrs.src) {
+                    //@ts-ignore
+                    node.attrs.src = node.attrs.src.replace(
+                      attachmentId,
+                      newAttachmentId,
+                    );
+                  }
+                }
+              }
+            });
+          });
+        }
+
+        const prosemirrorJson = prosemirrorDoc.toJSON();
+
+        return {
+          id: pageFromMap.newPageId,
+          slugId: pageFromMap.newSlugId,
+          title: page.title,
+          icon: page.icon,
+          content: prosemirrorJson,
+          textContent: jsonToText(prosemirrorJson),
+          ydoc: createYdocFromJson(prosemirrorJson),
+          position: page.id === rootPage.id ? nextPosition : page.position,
+          spaceId: spaceId,
+          workspaceId: page.workspaceId,
+          creatorId: authUser.id,
+          lastUpdatedById: authUser.id,
+          parentPageId: page.parentPageId
+            ? pageMap.get(page.parentPageId)?.newPageId
+            : null,
+        };
+      }),
+    );
+
+    await this.db.insertInto('pages').values(insertablePages).execute();
+
+    //TODO: best to handle this in a queue
+    const attachmentsIds = Array.from(attachmentMap.keys());
+    if (attachmentsIds.length > 0) {
+      const attachments = await this.db
+        .selectFrom('attachments')
+        .selectAll()
+        .where('id', 'in', attachmentsIds)
+        .where('workspaceId', '=', rootPage.workspaceId)
+        .execute();
+
+      for (const attachment of attachments) {
+        try {
+          const pageAttachment = attachmentMap.get(attachment.id);
+
+          // make sure the copied attachment belongs to the page it was copied from
+          if (attachment.pageId !== pageAttachment.oldPageId) {
+            continue;
+          }
+
+          const newAttachmentId = pageAttachment.newAttachmentId;
+
+          const newPageId = pageAttachment.newPageId;
+
+          const newPathFile = attachment.filePath.replace(
+            attachment.id,
+            newAttachmentId,
+          );
+          await this.storageService.copy(attachment.filePath, newPathFile);
+          await this.db
+            .insertInto('attachments')
+            .values({
+              id: newAttachmentId,
+              type: attachment.type,
+              filePath: newPathFile,
+              fileName: attachment.fileName,
+              fileSize: attachment.fileSize,
+              mimeType: attachment.mimeType,
+              fileExt: attachment.fileExt,
+              creatorId: attachment.creatorId,
+              workspaceId: attachment.workspaceId,
+              pageId: newPageId,
+              spaceId: spaceId,
+            })
+            .execute();
+        } catch (err) {
+          this.logger.log(err);
+        }
+      }
+    }
+
+    const newPageId = pageMap.get(rootPage.id).newPageId;
+    return await this.pageRepo.findById(newPageId, {
+      includeSpace: true,
+    });
+  }
+
   async movePage(dto: MovePageDto, movedPage: Page) {
     // validate position value by attempting to generate a key
     try {

apps/server/src/integrations/storage/drivers/local.driver.ts

@@ -25,6 +25,16 @@ export class LocalDriver implements StorageDriver {
     }
   }
 
+  async copy(fromFilePath: string, toFilePath: string): Promise<void> {
+    try {
+      if (await this.exists(fromFilePath)) {
+        await fs.copy(fromFilePath, toFilePath);
+      }
+    } catch (err) {
+      throw new Error(`Failed to copy file: ${(err as Error).message}`);
+    }
+  }
+
   async read(filePath: string): Promise<Buffer> {
     try {
       return await fs.readFile(this._fullPath(filePath));

apps/server/src/integrations/storage/drivers/s3.driver.ts

@@ -1,5 +1,6 @@
 import { S3StorageConfig, StorageDriver, StorageOption } from '../interfaces';
 import {
+  CopyObjectCommand,
   DeleteObjectCommand,
   GetObjectCommand,
   HeadObjectCommand,
@@ -39,6 +40,22 @@ export class S3Driver implements StorageDriver {
     }
   }
 
+  async copy(fromFilePath: string, toFilePath: string): Promise<void> {
+    try {
+      if (await this.exists(fromFilePath)) {
+        await this.s3Client.send(
+          new CopyObjectCommand({
+            Bucket: this.config.bucket,
+            CopySource: `${this.config.bucket}/${fromFilePath}`,
+            Key: toFilePath,
+          }),
+        );
+      }
+    } catch (err) {
+      throw new Error(`Failed to copy file: ${(err as Error).message}`);
+    }
+  }
+
   async read(filePath: string): Promise<Buffer> {
     try {
       const command = new GetObjectCommand({

apps/server/src/integrations/storage/interfaces/storage-driver.interface.ts

@@ -1,6 +1,8 @@
 export interface StorageDriver {
   upload(filePath: string, file: Buffer): Promise<void>;
 
+  copy(fromFilePath: string, toFilePath: string): Promise<void>;
+
   read(filePath: string): Promise<Buffer>;
 
   exists(filePath: string): Promise<boolean>;

apps/server/src/integrations/storage/storage.service.ts

@@ -14,6 +14,11 @@ export class StorageService {
     this.logger.debug(`File uploaded successfully. Path: ${filePath}`);
   }
 
+  async copy(fromFilePath: string, toFilePath: string) {
+    await this.storageDriver.copy(fromFilePath, toFilePath);
+    this.logger.debug(`File copied successfully. Path: ${toFilePath}`);
+  }
+
   async read(filePath: string): Promise<Buffer> {
     return this.storageDriver.read(filePath);
   }