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

@@ -9,6 +9,7 @@ import type User from '@domain/entities/user.js';
 import type { NoteList } from '@domain/entities/noteList.js';
 import type NoteHistoryRepository from '@repository/noteHistory.repository.js';
 import type { NoteHistoryMeta, NoteHistoryRecord, NoteHistoryPublic } from '@domain/entities/noteHistory.js';
+import type { NotePublic } from '@domain/entities/notePublic.js';
 
 /**
  * Note service
@@ -441,4 +442,15 @@ 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
+ * @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<NotePublic[]> {
+ return await this.noteRepository.getNoteParents(noteId, userId);
+ }
 }

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

@@ -1,6 +1,7 @@
 import { MemberRole } from '@domain/entities/team.js';
 import { describe, test, expect, beforeEach } from 'vitest';
 import type User from '@domain/entities/user.js';
+import type { Note } from '@domain/entities/note.js';
 
 describe('Note API', () => {
  /**
@@ -180,6 +181,49 @@ describe('Note API', () => {
  });
 
  describe('GET note/:notePublicId ', () => {
+ let context: {
+ user: User;
+ user2: User;
+ parentNote: Note;
+ childNote: Note;
+ differentChildNote: Note;
+ grandChildNote: Note;
+ } = {
+ user: {} as User,
+ user2: {} as User,
+ parentNote: {} as Note,
+ childNote: {} as Note,
+ differentChildNote: {} as Note,
+ grandChildNote: {} as Note,
+ };
+
+ beforeEach(async () => {
+ /** Create test user */
+ context.user = await global.db.insertUser();
+
+ context.user2 = await global.db.insertUser();
+
+ /** Create test note - a parent note */
+ context.parentNote = await global.db.insertNote({
+ creatorId: context.user.id,
+ });
+
+ /** Create test note - a child note */
+ context.childNote = await global.db.insertNote({
+ creatorId: context.user.id,
+ });
+
+ /** Create test note - create note with different user */
+ context.differentChildNote = await global.db.insertNote({
+ creatorId: context.user2.id,
+ });
+
+ /** Create test note - a grandchild note */
+ context.grandChildNote = await global.db.insertNote({
+ creatorId: context.user.id,
+ });
+ });
+
  test.each([
  /** Returns 200 if user is team member with a Read role */
  {
@@ -518,6 +562,191 @@ describe('Note API', () => {
 
  expect(response?.json().message).toStrictEqual(expectedMessage);
  });
+
+ test.each([
+ /** Returns two parents in case of relation between child and parent notes with 200 status */
+ {
+ testCase: 1,
+ numberOfNotes: 2,
+ childNoteCreatedByDifferentUser: false,
+ isPublic: true,
+ expectedStatusCode: 200,
+ },
+ /** Returns multiple parents in case of multiple notes relations with user presence in team in each note with 200 status */
+ {
+ testCase: 2,
+ numberOfNotes: 3,
+ childNoteCreatedByDifferentUser: false,
+ isPublic: true,
+ expectedStatusCode: 200,
+ },
+ /** Returns one parent in case where there is no note relation with 200 status */
+ {
+ testCase: 3,
+ numberOfNotes: 1,
+ childNoteCreatedByDifferentUser: false,
+ isPublic: true,
+ expectedStatusCode: 200,
+ },
+ /** Returns mutiple parents in case where user is not in the team of a note with 200 status */
+ {
+ testCase: 4,
+ numberOfNotes: 3,
+ childNoteCreatedByDifferentUser: true,
+ isPublic: true,
+ expectedStatusCode: 200,
+ },
+ /** Returns multiple parents in case when note is not public with 200 status */
+ {
+ testCase: 5,
+ numberOfNotes: 3,
+ childNoteCreatedByDifferentUser: true,
+ isPublic: false,
+ expectedStatusCode: 200,
+ },
+ /** Returns no note in case when the user is not authorized to note with 403 status */
+ {
+ testCase: 6,
+ numberOfNotes: 2,
+ childNoteCreatedByDifferentUser: true,
+ isPublic: false,
+ expectedStatusCode: 403,
+ },
+ /** Returns one note in case when the user has no access to note with 200 status */
+ {
+ testCase: 7,
+ numberOfNotes: 2,
+ childNoteCreatedByDifferentUser: true,
+ isPublic: true,
+ expectedStatusCode: 200,
+ },
+ ])('Get note parents in different scenarios', async ({ testCase, numberOfNotes, childNoteCreatedByDifferentUser, isPublic, expectedStatusCode }) => {
+ if (context !== undefined) {
+ /** Create acces token for the user */
+ let accessToken = global.auth(context.user.id);
+
+ if (testCase === 6 || testCase == 7) {
+ accessToken = global.auth(context.user2.id);
+ }
+ let noteId = context.parentNote.id;
+ let notePublicId = context.parentNote.publicId;
+
+ if (numberOfNotes == 2 && !childNoteCreatedByDifferentUser) {
+ noteId = context.childNote.id;
+ notePublicId = context.childNote.publicId;
+ } else if (numberOfNotes == 2 && childNoteCreatedByDifferentUser) {
+ noteId = context.differentChildNote.id;
+ notePublicId = context.differentChildNote.publicId;
+ } else if (numberOfNotes == 3) {
+ noteId = context.grandChildNote.id;
+ notePublicId = context.grandChildNote.publicId;
+ }
+
+ /** Create test note settings */
+ await global.db.insertNoteSetting({
+ noteId: noteId,
+ isPublic: isPublic,
+ });
+
+ for (let i = 0; i < numberOfNotes - 1; i++) {
+ /** Create test note relation */
+ await global.db.insertNoteRelation({
+ parentId: i == 0 ? context.parentNote.id : (childNoteCreatedByDifferentUser ? context.differentChildNote.id : context.childNote.id),
+ noteId: i == 0 ? (childNoteCreatedByDifferentUser ? context.differentChildNote.id : context.childNote.id) : context.grandChildNote.id,
+ });
+ }
+
+ const response = await global.api?.fakeRequest({
+ method: 'GET',
+ headers: {
+ authorization: `Bearer ${accessToken}`,
+ },
+ url: `/note/${notePublicId}`,
+ });
+
+ switch (testCase) {
+ case (1):
+ expect(response?.statusCode).toBe(expectedStatusCode);
+ expect(response?.json()).toMatchObject({
+ parents: [
+ {
+ id: context.parentNote.publicId,
+ content: context.parentNote.content,
+ },
+ {
+ id: context.childNote.publicId,
+ content: context.childNote.content,
+ },
+ ],
+ });
+ break;
+ case (2):
+ expect(response?.statusCode).toBe(expectedStatusCode);
+ expect(response?.json()).toMatchObject({
+ parents: [
+ {
+ id: context.parentNote.publicId,
+ content: context.parentNote.content,
+ },
+ {
+ id: context.childNote.publicId,
+ content: context.childNote.content,
+ },
+ {
+ id: context.grandChildNote.publicId,
+ content: context.grandChildNote.content,
+ },
+ ],
+ });
+ break;
+ case (3):
+ expect(response?.statusCode).toBe(expectedStatusCode);
+ expect(response?.json()).toMatchObject({
+ parents: [
+ {
+ id: context.parentNote.publicId,
+ content: context.parentNote.content,
+ },
+ ],
+ });
+ break;
+ case (4):
+ case (5):
+ expect(response?.statusCode).toBe(expectedStatusCode);
+ expect(response?.json()).toMatchObject({
+ parents: [
+ {
+ id: context.parentNote.publicId,
+ content: context.parentNote.content,
+ },
+ {
+ id: context.differentChildNote.publicId,
+ content: context.differentChildNote.content,
+ },
+ {
+ id: context.grandChildNote.publicId,
+ content: context.grandChildNote.content,
+ },
+ ],
+ });
+ break;
+ case (6):
+ expect(response?.statusCode).toBe(expectedStatusCode);
+ break;
+ case (7):
+ expect(response?.statusCode).toBe(expectedStatusCode);
+ expect(response?.json()).toMatchObject({
+ parents: [
+ {
+ id: context.differentChildNote.publicId,
+ content: context.differentChildNote.content,
+ },
+ ],
+ });
+ break;
+ }
+ }
+ });
  });
 
  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,14 @@ const NoteRouter: FastifyPluginCallback<NoteRouterOptions> = (fastify, opts, don
  */
  const canEdit = memberRole === MemberRole.Write;
 
+ const noteParentStructure = await noteService.getNoteParentStructure(noteId, userId!);
+
  return reply.send({
  note: notePublic,
  parentNote: parentNote,
  accessRights: { canEdit: canEdit },
  tools: noteTools,
+ parents: noteParentStructure,
  });
  });
 

src/repository/index.ts

@@ -133,12 +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);
 
  /**
  * 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 type { NotePublic } from '@domain/entities/notePublic.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 getNoteParents(noteId: NoteInternalId, userId: number): Promise<NotePublic[]> {
+ return await this.storage.getAllNoteParents(noteId, userId);
+ }
 }