update (parents note): modification based on the reviews, still tests…

… to be fixed

docker-compose.yml

@@ -7,7 +7,6 @@ services:
       - 127.0.0.1:1337:1337
     volumes:
       - ./app-config.yaml:/usr/app/app-config.yaml
-      - ./app-config.local.yaml:/usr/app/app-config.local.yaml
     restart: unless-stopped
 
   postgres:

src/domain/entities/note.ts

@@ -82,25 +82,3 @@ export interface Note {
  * Part of note entity used to create new note
  */
 export type NoteCreationAttributes = Pick<Note, 'publicId' | 'content' | 'creatorId' | 'tools'>;
-
-/**
- * This type represents only note's content
- * Used for work with just note's content in web part
- * This type would be used as a part of the structure, that represents all parent notes of the current note
- */
-export type NoteIdAndContent = {
-  /**
-   * Note public id
-   */
-  noteId: Note['publicId'];
-
-  /**
-   * Note content
-   */
-  content: Note['content'];
-};
-
-/**
- * This type represents the structure, that represents all parent notes of the current note
- */
-export type NoteParentsStructure = NoteIdAndContent[];

src/domain/service/note.ts

@@ -1,4 +1,4 @@
-import type { Note, NoteInternalId, NoteParentsStructure, NotePublicId } from '@domain/entities/note.js';
+import type { Note, NoteInternalId, NotePublicId } from '@domain/entities/note.js';
 import type NoteRepository from '@repository/note.repository.js';
 import type NoteVisitsRepository from '@repository/noteVisits.repository.js';
 import { createPublicId } from '@infrastructure/utils/id.js';
@@ -457,7 +457,7 @@ export default class NoteService {
    * @param userId - id of the user that is requesting the parent structure
    * @returns - array of notes that are parent structure of the note
    */
-  public async getNoteParentStructure(noteId: NoteInternalId, userId: number): Promise<NoteParentsStructure> {
-    return await this.teamRepository.getAllNotesParents(noteId, userId);
+  public async getNoteParentStructure(noteId: NoteInternalId, userId: number): Promise<NoteList> {
+    return await this.noteRepository.getAllNotesParents(noteId, userId);
   }
 }

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

@@ -519,7 +519,7 @@ describe('Note API', () => {
       expect(response?.json().message).toStrictEqual(expectedMessage);
     });
 
-    test('Returns two objects of note parent structure by note public id with 200 status', async () => {
+    test('Returns two parents in case of relation between child and parent notes with 200 status', async () => {
       /** Create test user */
       const user = await global.db.insertUser();
 
@@ -559,20 +559,22 @@ describe('Note API', () => {
       expect(response?.statusCode).toBe(200);
 
       expect(response?.json()).toMatchObject({
-        parentStructure: [
-          {
-            noteId: parentNote.publicId,
-            content: parentNote.content,
-          },
-          {
-            noteId: childNote.publicId,
-            content: childNote.content,
-          },
-        ],
+        parents: {
+          items: [
+            {
+              id: parentNote.publicId,
+              content: parentNote.content,
+            },
+            {
+              id: childNote.publicId,
+              content: childNote.content,
+            },
+          ],
+        },
       });
     });
 
-    test('Returns multiple objects of note parent structure by note public id with 200 status', async () => {
+    test('Returns multiple parents in case of multiple notes relations with user presence in team in each note with 200 status', async () => {
       /** Create test user */
       const user = await global.db.insertUser();
 
@@ -622,24 +624,26 @@ describe('Note API', () => {
       expect(response?.statusCode).toBe(200);
 
       expect(response?.json()).toMatchObject({
-        parentStructure: [
-          {
-            noteId: parentNote.publicId,
-            content: parentNote.content,
-          },
-          {
-            noteId: childNote.publicId,
-            content: childNote.content,
-          },
-          {
-            noteId: grandchildNote.publicId,
-            content: grandchildNote.content,
-          },
-        ],
+        parents: {
+          items: [
+            {
+              id: parentNote.publicId,
+              content: parentNote.content
+            },
+            {
+              id: childNote.publicId,
+              content: childNote.content
+            },
+            {
+              id: grandchildNote.publicId,
+              content: grandchildNote.content
+            },
+          ],
+        }
       });
     });
 
-    test('Returns one object in array of note parent structure by note public id with 200 status', async () => {
+    test('Returns one parent in case where there is no note relation with 200 status', async () => {
       /** Create test user */
       const user = await global.db.insertUser();
 
@@ -667,12 +671,14 @@ describe('Note API', () => {
       expect(response?.statusCode).toBe(200);
 
       expect(response?.json()).toMatchObject({
-        parentStructure: [
-          {
-            noteId: note.publicId,
-            content: note.content,
-          },
-        ],
+        parents: {
+          items: [
+            {
+              id: note.publicId,
+              content: note.content,
+            },
+          ],
+        }
       });
     });
   });

src/presentation/http/router/note.ts

@@ -2,7 +2,7 @@ import type { FastifyPluginCallback } from 'fastify';
 import type NoteService from '@domain/service/note.js';
 import type NoteSettingsService from '@domain/service/noteSettings.js';
 import type { ErrorResponse } from '@presentation/http/types/HttpResponse.js';
-import type { Note, NoteParentsStructure, NotePublicId } from '@domain/entities/note.js';
+import type { Note, NotePublicId } from '@domain/entities/note.js';
 import useNoteResolver from '../middlewares/note/useNoteResolver.js';
 import useNoteSettingsResolver from '../middlewares/noteSettings/useNoteSettingsResolver.js';
 import useMemberRoleResolver from '../middlewares/noteSettings/useMemberRoleResolver.js';
@@ -12,6 +12,7 @@ import type NoteVisitsService from '@domain/service/noteVisits.js';
 import type EditorToolsService from '@domain/service/editorTools.js';
 import type EditorTool from '@domain/entities/editorTools.js';
 import type { NoteHistoryMeta, NoteHistoryPublic, NoteHistoryRecord } from '@domain/entities/noteHistory.js';
+import { NoteList } from '@domain/entities/noteList.js';
 
 /**
  * Interface for the note router.
@@ -85,7 +86,7 @@ const NoteRouter: FastifyPluginCallback<NoteRouterOptions> = (fastify, opts, don
         canEdit: boolean;
       };
       tools: EditorTool[];
-      parentStructure: NoteParentsStructure;
+      parents: NoteList;
     } | ErrorResponse;
   }>('/:notePublicId', {
     config: {
@@ -124,16 +125,13 @@ const NoteRouter: FastifyPluginCallback<NoteRouterOptions> = (fastify, opts, don
                 $ref: 'EditorToolSchema',
               },
             },
-            parentStructure: {
-              type: 'array',
-              items: {
-                type: 'object',
-                properties: {
-                  noteId: {
-                    $ref: 'NoteSchema#/properties/id',
-                  },
-                  content: {
-                    $ref: 'NoteSchema#/properties/content',
+            parents: {
+              type: 'object',
+              properties: {
+                items: {
+                  type: 'array',
+                  items: {
+                    $ref: 'NoteSchema',
                   },
                 },
               },
@@ -194,7 +192,7 @@ const NoteRouter: FastifyPluginCallback<NoteRouterOptions> = (fastify, opts, don
       parentNote: parentNote,
       accessRights: { canEdit: canEdit },
       tools: noteTools,
-      parentStructure: noteParentStructure,
+      parents: noteParentStructure,
     });
   });
 

src/repository/index.ts

@@ -133,13 +133,14 @@ export async function init(orm: Orm, s3Config: S3StorageConfig): Promise<Reposit
   /**
    * Create associations between note and team, user and team
    */
+  noteStorage.createAssociationWithTeamsModel(teamStorage.model);
   teamStorage.createAssociationWithNoteModel(noteStorage.model);
   teamStorage.createAssociationWithUserModel(userStorage.model);
-  teamStorage.createAssociationWithNoteRelationsModel(noteRelationshipStorage.model);
 
   /**
    * Create associations between note and relations table
    */
+  noteStorage.createAssociationWithNoteRelationModel(noteRelationshipStorage.model);
   noteRelationshipStorage.createAssociationWithNoteModel(noteStorage.model);
 
   /**

src/repository/note.repository.ts

@@ -1,4 +1,5 @@
 import type { Note, NoteCreationAttributes, NoteInternalId, NotePublicId } from '@domain/entities/note.js';
+import { NoteList } from '@domain/entities/noteList.js';
 import type NoteStorage from '@repository/storage/note.storage.js';
 
 /**
@@ -81,4 +82,14 @@ 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 parents based on note id and user id, by checking team access
+   * @param noteId : note id to get all its parents
+   * @param userId : user id to check access
+   * @returns an array of note parents objects containing public id and content
+   */
+  public async getAllNotesParents(noteId: NoteInternalId, userId: number): Promise<NoteList> {
+    return await this.storage.getAllNoteParents(noteId, userId);
+  }
 }

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

@@ -6,6 +6,10 @@ import { UserModel } from '@repository/storage/postgres/orm/sequelize/user.js';
 import type { NoteSettingsModel } from './noteSettings.js';
 import type { NoteVisitsModel } from './noteVisits.js';
 import type { NoteHistoryModel } from './noteHistory.js';
+import { NoteRelationsModel } from './noteRelations.js';
+import { notEmpty } from '@infrastructure/utils/empty.js';
+import { NoteList } from '@domain/entities/noteList.js';
+import { TeamsModel } from './teams.js';
 
 /* eslint-disable @typescript-eslint/naming-convention */
 
@@ -75,6 +79,10 @@ export default class NoteSequelizeStorage {
 
   public historyModel: typeof NoteHistoryModel | null = null;
 
+  public noteRelationModel: typeof NoteRelationsModel | null = null;
+
+  public teamModel: typeof TeamsModel | null = null;
+
   /**
    * Database instance
    */
@@ -155,6 +163,22 @@ export default class NoteSequelizeStorage {
     });
   };
 
+  public createAssociationWithNoteRelationModel(model: ModelStatic<NoteRelationsModel>): void {
+
+    /**
+     * Create association with note relations
+     */
+    this.noteRelationModel = model;
+  }
+
+  public createAssociationWithTeamsModel(model: ModelStatic<TeamsModel>): void {
+
+    /**
+     * Create association with teams
+    */
+    this.teamModel = model;
+  }
+
   /**
    * Insert note to database
    * @param options - note creation options
@@ -323,4 +347,68 @@ export default class NoteSequelizeStorage {
       },
     });
   };
+
+
+  /**
+   * Get all parent notes of a note that a user has access to,
+   * by checking the team access.
+   * @param noteId - the ID of the note.
+   * @param userId - the ID of the user.
+   */
+  public async getAllNoteParents(noteId: NoteInternalId, userId: number): Promise<NoteList> {
+    if (!this.teamModel || !this.noteRelationModel) {
+      throw new Error(`${this.model !== null ? 'TeamStorage: Note relation model is not defined' : 'TeamStorage: Note model is not defined'}`);
+    }
+
+    const parentNotes: NoteList = { items: [] };
+    let currentNoteId: NoteInternalId | null = noteId;
+    /**
+     * Store notes that user can not access, to check the inherited team if has access
+     */
+    let storeUnaccessibleNote: Note[] = [];
+
+    while (currentNoteId != null) {
+      const teamMember = await this.teamModel.findOne({
+        where: {
+          noteId: currentNoteId,
+          userId,
+        },
+        include: {
+          model: this.model,
+          as: this.model.tableName,
+          required: true,
+        },
+      });
+
+      if (teamMember && notEmpty(teamMember.notes)) {
+        if (storeUnaccessibleNote.length > 0) {
+          parentNotes.items.push(...storeUnaccessibleNote);
+          storeUnaccessibleNote = [];
+        }
+        parentNotes.items.push(teamMember.notes);
+      } else if (teamMember === null) {
+        const note = await this.model.findOne({
+          where: { id: currentNoteId },
+        });
+
+        if (note !== null) {
+          storeUnaccessibleNote.push(note);
+        }
+      }
+
+      // Retrieve the parent note
+      const noteRelation: NoteRelationsModel | null = await this.noteRelationModel.findOne({
+        where: { noteId: currentNoteId },
+      });
+
+      if (noteRelation != null) {
+        currentNoteId = noteRelation.parentId;
+      } else {
+        currentNoteId = null;
+      }
+    }
+
+    parentNotes.items.reverse();
+    return parentNotes;
+  }
 }