feat(parent structure): add method that return note parent structure

docker-compose.yml

@@ -1,4 +1,5 @@
-version: "3.2"
+version: '3.2'
+
 services:
   api:
     build:

src/domain/service/note.ts

@@ -441,4 +441,17 @@ export default class NoteService {
 
     return noteHistoryPublic;
   }
+
+  /**
+   * Get note parent structure recursively by note id and user id
+   * and check if user has access to the parent note.
+   * @param noteId - id of the note to get parent structure
+   * @returns - array of notes that are parent structure of the note
+   */
+  public async getNoteParents(noteId: NoteInternalId): Promise<Note[]> {
+    const noteIds: NoteInternalId[] = await this.noteRelationsRepository.getNoteParentsIds(noteId);
+    const noteParents = await this.noteRepository.getNotesByIds(noteIds);
+
+    return noteParents;
+  }
 }

src/presentation/http/router/note.test.ts

@@ -518,6 +518,204 @@ describe('Note API', () => {
 
       expect(response?.json().message).toStrictEqual(expectedMessage);
     });
+
+    test('Returns one parents note in case when note has one parent', async () => {
+      /** Create test user */
+      const user = await global.db.insertUser();
+
+      /** Create access token for the user */
+      const accessToken = global.auth(user.id);
+
+      /** Create test note - a parent note */
+      const parentNote = await global.db.insertNote({
+        creatorId: user.id,
+      });
+
+      /** Create test note - a child note */
+      const childNote = await global.db.insertNote({
+        creatorId: user.id,
+      });
+
+      /** Create test note settings */
+      await global.db.insertNoteSetting({
+        noteId: childNote.id,
+        isPublic: true,
+      });
+
+      /** Create test note relation */
+      await global.db.insertNoteRelation({
+        parentId: parentNote.id,
+        noteId: childNote.id,
+      });
+
+      const response = await global.api?.fakeRequest({
+        method: 'GET',
+        headers: {
+          authorization: `Bearer ${accessToken}`,
+        },
+        url: `/note/${childNote.publicId}`,
+      });
+
+      expect(response?.statusCode).toBe(200);
+
+      expect(response?.json()).toMatchObject({
+        parents: [
+          {
+            id: parentNote.publicId,
+            content: parentNote.content,
+          },
+        ],
+      });
+    });
+
+    test('Returns two note parents in case when note has two parents', async () => {
+      /** Create test user */
+      const user = await global.db.insertUser();
+
+      /** Create access token for the user */
+      const accessToken = global.auth(user.id);
+
+      /** Create test note - a grand parent note */
+      const grandParentNote = await global.db.insertNote({
+        creatorId: user.id,
+      });
+
+      /** Create test note - a parent note */
+      const parentNote = await global.db.insertNote({
+        creatorId: user.id,
+      });
+
+      /** Create test note - a child note */
+      const childNote = await global.db.insertNote({
+        creatorId: user.id,
+      });
+
+      /** Create test note settings */
+      await global.db.insertNoteSetting({
+        noteId: childNote.id,
+        isPublic: true,
+      });
+
+      /** Create note relation between parent and grandParentNote */
+      await global.db.insertNoteRelation({
+        parentId: grandParentNote.id,
+        noteId: parentNote.id,
+      });
+
+      /** Create test note relation */
+      await global.db.insertNoteRelation({
+        parentId: parentNote.id,
+        noteId: childNote.id,
+      });
+
+      const response = await global.api?.fakeRequest({
+        method: 'GET',
+        headers: {
+          authorization: `Bearer ${accessToken}`,
+        },
+        url: `/note/${childNote.publicId}`,
+      });
+
+      expect(response?.statusCode).toBe(200);
+
+      expect(response?.json()).toMatchObject({
+        parents: [
+          {
+            id: grandParentNote.publicId,
+            content: grandParentNote.content,
+          },
+          {
+            id: parentNote.publicId,
+            content: parentNote.content,
+          },
+        ],
+      });
+    });
+
+    test('Returns one parent note when the user is not in the parent note\'s team but has note relation', async () => {
+      /** Create test user */
+      const user = await global.db.insertUser();
+
+      /** Create another user */
+      const anotherUser = await global.db.insertUser();
+
+      /** Create access token for the user */
+      const accessToken = global.auth(user.id);
+
+      /** Create test note - a parent note */
+      const parentNote = await global.db.insertNote({
+        creatorId: anotherUser.id,
+      });
+
+      /** Create test note - a child note */
+      const childNote = await global.db.insertNote({
+        creatorId: user.id,
+      });
+
+      /** Create test note settings */
+      await global.db.insertNoteSetting({
+        noteId: childNote.id,
+        isPublic: true,
+      });
+
+      /** Create test note relation */
+      await global.db.insertNoteRelation({
+        parentId: parentNote.id,
+        noteId: childNote.id,
+      });
+
+      const response = await global.api?.fakeRequest({
+        method: 'GET',
+        headers: {
+          authorization: `Bearer ${accessToken}`,
+        },
+        url: `/note/${childNote.publicId}`,
+      });
+
+      expect(response?.statusCode).toBe(200);
+
+      expect(response?.json()).toMatchObject({
+        parents: [
+          {
+            id: parentNote.publicId,
+            content: parentNote.content,
+          },
+        ],
+      });
+    });
+
+    test('Returns empty array in case where there is no relation exist for the note with status 200', async () => {
+      /** Create test user */
+      const user = await global.db.insertUser();
+
+      /** Create access token for the user */
+      const accessToken = global.auth(user.id);
+
+      /** Create test note - a child note */
+      const note = await global.db.insertNote({
+        creatorId: user.id,
+      });
+
+      /** Create test note settings */
+      await global.db.insertNoteSetting({
+        noteId: note.id,
+        isPublic: true,
+      });
+
+      const response = await global.api?.fakeRequest({
+        method: 'GET',
+        headers: {
+          authorization: `Bearer ${accessToken}`,
+        },
+        url: `/note/${note.publicId}`,
+      });
+
+      expect(response?.statusCode).toBe(200);
+
+      expect(response?.json()).toMatchObject({
+        parents: [],
+      });
+    });
   });
 
   describe('PATCH note/:notePublicId ', () => {

src/presentation/http/router/note.ts

@@ -85,6 +85,7 @@ const NoteRouter: FastifyPluginCallback<NoteRouterOptions> = (fastify, opts, don
         canEdit: boolean;
       };
       tools: EditorTool[];
+      parents: NotePublic[];
     } | ErrorResponse;
   }>('/:notePublicId', {
     config: {
@@ -123,6 +124,12 @@ const NoteRouter: FastifyPluginCallback<NoteRouterOptions> = (fastify, opts, don
                 $ref: 'EditorToolSchema',
               },
             },
+            parents: {
+              type: 'array',
+              items: {
+                $ref: 'NoteSchema',
+              },
+            },
           },
         },
       },
@@ -172,11 +179,18 @@ const NoteRouter: FastifyPluginCallback<NoteRouterOptions> = (fastify, opts, don
      */
     const canEdit = memberRole === MemberRole.Write;
 
+    const noteParentStructure = await noteService.getNoteParents(noteId);
+
+    const noteParentsPublic = noteParentStructure.map((notes) => {
+      return definePublicNote(notes);
+    });
+
     return reply.send({
       note: notePublic,
       parentNote: parentNote,
       accessRights: { canEdit: canEdit },
       tools: noteTools,
+      parents: noteParentsPublic,
     });
   });
 

src/repository/note.repository.ts

@@ -81,4 +81,13 @@ export default class NoteRepository {
   public async getNoteListByUserId(id: number, offset: number, limit: number): Promise<Note[]> {
     return await this.storage.getNoteListByUserId(id, offset, limit);
   }
+
+  /**
+   * Get all notes based on their ids
+   * @param noteIds : list of note ids
+   * @returns an array of notes
+   */
+  public async getNotesByIds(noteIds: NoteInternalId[]): Promise<Note[]> {
+    return await this.storage.getNotesByIds(noteIds);
+  }
 }

src/repository/noteRelations.repository.ts

@@ -67,4 +67,13 @@ export default class NoteRelationsRepository {
   public async hasRelation(noteId: NoteInternalId): Promise<boolean> {
     return await this.storage.hasRelation(noteId);
   }
+
+  /**
+   * Get all note parents based on note id
+   * @param noteId : note id to get all its parents
+   * @returns an array of note parents ids
+   */
+  public async getNoteParentsIds(noteId: NoteInternalId): Promise<NoteInternalId[]> {
+    return await this.storage.getNoteParentsIds(noteId);
+  }
 }

src/repository/storage/postgres/orm/sequelize/note.ts

@@ -1,11 +1,10 @@
 import type { CreationOptional, InferAttributes, InferCreationAttributes, ModelStatic, NonAttribute, Sequelize } from 'sequelize';
-import { DataTypes, Model } from 'sequelize';
+import { DataTypes, Model, Op } from 'sequelize';
 import type Orm from '@repository/storage/postgres/orm/sequelize/index.js';
 import type { Note, NoteCreationAttributes, NoteInternalId, NotePublicId } from '@domain/entities/note.js';
 import { UserModel } from '@repository/storage/postgres/orm/sequelize/user.js';
 import type { NoteSettingsModel } from './noteSettings.js';
 import type { NoteVisitsModel } from './noteVisits.js';
-import { DomainError } from '@domain/entities/DomainError.js';
 import type { NoteHistoryModel } from './noteHistory.js';
 
 /* eslint-disable @typescript-eslint/naming-convention */
@@ -233,11 +232,11 @@ export default class NoteSequelizeStorage {
    */
   public async getNoteListByUserId(userId: number, offset: number, limit: number): Promise<Note[]> {
     if (this.visitsModel === null) {
-      throw new DomainError('NoteVisit model should be defined');
+      throw new Error('NoteStorage: NoteVisit model should be defined');
     }
 
     if (!this.settingsModel) {
-      throw new Error('Note settings model not initialized');
+      throw new Error('NoteStorage: Note settings model not initialized');
     }
 
     const reply = await this.model.findAll({
@@ -293,7 +292,7 @@ export default class NoteSequelizeStorage {
    */
   public async getNoteByHostname(hostname: string): Promise<Note | null> {
     if (!this.settingsModel) {
-      throw new Error('Note settings model not initialized');
+      throw new Error('NoteStorage: Note settings model not initialized');
     }
 
     /**
@@ -324,4 +323,20 @@ export default class NoteSequelizeStorage {
       },
     });
   };
+
+  /**
+   * Get all notes based on their ids
+   * @param noteIds - list of note ids
+   */
+  public async getNotesByIds(noteIds: NoteInternalId[]): Promise<Note[]> {
+    const notes: Note[] = await this.model.findAll({
+      where: {
+        id: {
+          [Op.in]: noteIds,
+        },
+      },
+    });
+
+    return notes;
+  }
 }

src/repository/storage/postgres/orm/sequelize/noteRelations.ts

@@ -1,4 +1,5 @@
 import type { CreationOptional, InferAttributes, InferCreationAttributes, ModelStatic, Sequelize } from 'sequelize';
+import { QueryTypes } from 'sequelize';
 import { Op } from 'sequelize';
 import { NoteModel } from '@repository/storage/postgres/orm/sequelize/note.js';
 import type Orm from '@repository/storage/postgres/orm/sequelize/index.js';
@@ -209,4 +210,36 @@ export default class NoteRelationsSequelizeStorage {
 
     return foundNote !== null;
   };
+
+  /**
+   * Get all parent notes of a note that a user has access to,
+   * where the user has access to.
+   * @param noteId - the ID of the note.
+   */
+  public async getNoteParentsIds(noteId: NoteInternalId): Promise<NoteInternalId[]> {
+    // get all note ids via a singe sql query instead of many
+    const query = `
+    WITH RECURSIVE note_parents AS (
+      SELECT np.note_id, np.parent_id
+      FROM ${String(this.database.literal(this.tableName).val)} np
+      WHERE np.note_id = :startNoteId
+      UNION ALL
+      SELECT nr.note_id, nr.parent_id
+      FROM ${String(this.database.literal(this.tableName).val)} nr
+      INNER JOIN note_parents np ON np.parent_id = nr.note_id
+    )
+    SELECT np.note_id AS "noteId", np.parent_id AS "parentId"
+    FROM note_parents np;`;
+
+    const result = await this.model.sequelize?.query(query, {
+      replacements: { startNoteId: noteId },
+      type: QueryTypes.SELECT,
+    });
+
+    let noteParents = (result as { noteId: number; parentId: number }[])?.map(note => note.parentId) ?? [];
+
+    noteParents.reverse();
+
+    return noteParents;
+  }
 }