feat: added ability to join note team

migrations/tenant/0016-note-teams@add-auto-increment-id.sql

@@ -0,0 +1,14 @@
+CREATE SEQUENCE IF NOT EXISTS public.note_teams_id_seq
+    AS integer
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+ALTER TABLE public.note_teams_id_seq OWNER TO codex;
+
+ALTER SEQUENCE public.note_teams_id_seq OWNED BY public.note_teams.id;
+
+-- Make identifier default value incrementing
+ALTER TABLE ONLY public.note_teams ALTER COLUMN id SET DEFAULT nextval('public.note_teams_id_seq'::regclass);

src/domain/entities/team.ts

@@ -3,14 +3,14 @@ import type User from './user.js';
 
 export enum MemberRole {
   /**
-   * Team member can read and write notes
+   * Team member can only read notes
    */
-  read = 'read',
+  read = 0,
 
   /**
-   * Team member can only read notes
+   * Team member can read and write notes
    */
-  write = 'write',
+  write = 1,
 }
 
 /**
@@ -36,7 +36,7 @@ export interface TeamMember {
   /**
    * Team member role, show what user can do with note
    */
-  role:  MemberRole;
+  role: MemberRole;
 }
 
 export type Team = TeamMember[];

src/domain/service/noteSettings.ts

@@ -1,8 +1,10 @@
 import type { NoteInternalId } from '@domain/entities/note.js';
+import type { InvitationHash } from '@domain/entities/noteSettings.js';
 import type NoteSettings from '@domain/entities/noteSettings.js';
 import type NoteSettingsRepository from '@repository/noteSettings.repository.js';
 import type TeamRepository from '@repository/team.repository.js';
-import type { MemberRole, Team, TeamMember, TeamMemberCreationAttributes } from '@domain/entities/team.js';
+import type { Team, TeamMember, TeamMemberCreationAttributes } from '@domain/entities/team.js';
+import { MemberRole } from '@domain/entities/team.js';
 import type User from '@domain/entities/user.js';
 import { createInvitationHash } from '@infrastructure/utils/invitationHash.js';
 
@@ -20,14 +22,47 @@ export default class NoteSettingsService {
   /**
    * Note Settings service constructor
    *
-   * @param noteSettingsrepository - note settings repository
+   * @param noteSettingsRepository - note settings repository
    * @param teamRepository - team repository
    */
-  constructor(noteSettingsrepository: NoteSettingsRepository, teamRepository: TeamRepository) {
-    this.noteSettingsRepository = noteSettingsrepository;
+  constructor(noteSettingsRepository: NoteSettingsRepository, teamRepository: TeamRepository) {
+    this.noteSettingsRepository = noteSettingsRepository;
     this.teamRepository = teamRepository;
   }
 
+  /**
+   * Add user to the team by invitation hash
+   *
+   * @param invitationHash - hash for joining to the team
+   * @param userId - user to add
+   */
+  public async addUserToTeamByInvitationHash(invitationHash: InvitationHash, userId: User['id']): Promise<TeamMember | null> {
+    const defaultUserRole = MemberRole.read;
+    const noteSettings = await this.noteSettingsRepository.getNoteSettingsByInvitationHash(invitationHash);
+
+    /**
+     * Check if invitation hash is valid
+     */
+    if (noteSettings === null) {
+      throw new Error(`Wrong invitation`);
+    }
+
+    /**
+     * Check if user not already in team
+     */
+    const isUserTeamMember = await this.teamRepository.isUserInTeam(userId, noteSettings.noteId);
+
+    if (isUserTeamMember) {
+      throw new Error(`User already in team`);
+    }
+
+    return await this.teamRepository.createTeamMembership({
+      noteId: noteSettings.noteId,
+      userId,
+      role: defaultUserRole,
+    });
+  }
+
   /**
    * Returns settings for a note with passed id
    *
@@ -102,6 +137,6 @@ export default class NoteSettingsService {
    * @returns created team member
    */
   public async createTeamMember(team: TeamMemberCreationAttributes): Promise<TeamMember> {
-    return await this.teamRepository.create(team);
+    return await this.teamRepository.createTeamMembership(team);
   }
 }

src/presentation/http/http-api.ts

@@ -24,6 +24,8 @@ import type { RequestParams, Response } from '@presentation/api.interface.js';
 import NoteSettingsRouter from './router/noteSettings.js';
 import NoteListRouter from '@presentation/http/router/noteList.js';
 import { EditorToolSchema } from './schema/EditorTool.js';
+import JoinRouter from '@presentation/http/router/join.js';
+import { JoinSchemaParams, JoinSchemaResponse } from './schema/Join.js';
 
 
 const appServerLogger = getLogger('appServer');
@@ -197,6 +199,11 @@ export default class HttpApi implements Api {
       noteListService: domainServices.noteListService,
     });
 
+    await this.server?.register(JoinRouter, {
+      prefix: '/join',
+      noteSettings: domainServices.noteSettingsService,
+    });
+
     await this.server?.register(NoteSettingsRouter, {
       prefix: '/note-settings',
       noteSettingsService: domainServices.noteSettingsService,
@@ -268,6 +275,8 @@ export default class HttpApi implements Api {
     this.server?.addSchema(UserSchema);
     this.server?.addSchema(NoteSchema);
     this.server?.addSchema(EditorToolSchema);
+    this.server?.addSchema(JoinSchemaParams);
+    this.server?.addSchema(JoinSchemaResponse);
   }
 
   /**

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

@@ -0,0 +1,69 @@
+import { describe, test, expect } from 'vitest';
+
+describe('Join API', () => {
+  describe('POST /join/:hash', () => {
+    test('Returns 406 when user is already in the team', async () => {
+      const hash = 'Hzh2hy4igf';
+      const userId = 2;
+      const accessToken = global.auth(userId);
+
+      const response = await global.api?.fakeRequest({
+        method: 'POST',
+        headers: {
+          authorization: `Bearer ${accessToken}`,
+        },
+        url: `/join/${hash}`,
+      });
+
+      expect(response?.statusCode).toBe(406);
+
+      expect(await response?.json()).toStrictEqual({
+        message: 'User already in team',
+      });
+    });
+    test('Returns 406 when invitation hash is not valid', async () => {
+      const hash = 'Jih23y4igf';
+      const userId = 4;
+      const accessToken = global.auth(userId);
+
+      const response = await global.api?.fakeRequest({
+        method: 'POST',
+        headers: {
+          authorization: `Bearer ${accessToken}`,
+        },
+        url: `/join/${hash}`,
+      });
+
+      expect(response?.statusCode).toBe(406);
+
+      expect(await response?.json()).toStrictEqual({
+        message: `Wrong invitation`,
+      });
+    });
+
+    test('Returns 200 when user is added to the team', async () => {
+      const hash = 'Hzh2hy4igf';
+      const userId = 1;
+      const accessToken = global.auth(userId);
+
+      const response = await global.api?.fakeRequest({
+        method: 'POST',
+        headers: {
+          authorization: `Bearer ${accessToken}`,
+        },
+        url: `/join/${hash}`,
+      });
+
+      expect(response?.statusCode).toBe(200);
+
+      expect(response?.json()).toStrictEqual({
+        result: {
+          id: 2,
+          userId,
+          noteId: 1,
+          role: 0,
+        },
+      });
+    });
+  });
+});

src/presentation/http/router/join.ts

@@ -0,0 +1,75 @@
+import type { FastifyPluginCallback } from 'fastify';
+import type NoteSettingsService from '@domain/service/noteSettings.js';
+import type { TeamMember } from '@domain/entities/team.js';
+
+/**
+ * Represents AI router options
+ */
+interface JoinRouterOptions {
+  /**
+   * Note settings service instance
+   */
+  noteSettings: NoteSettingsService
+}
+
+/**
+ * Join Router plugin
+ *
+ * @todo use different replies for different errors in post route
+ * @todo add check for write permission in route
+ * @param fastify - fastify instance
+ * @param opts - router options
+ * @param done - done callback
+ */
+const JoinRouter: FastifyPluginCallback<JoinRouterOptions> = (fastify, opts, done) => {
+  const noteSettingsService = opts.noteSettings;
+
+  fastify.post<{
+    Params: {
+      hash: string
+    }
+  }>('/:hash', {
+    schema: {
+      params: {
+        hash: {
+          $ref: 'JoinSchemaParams#/properties/hash',
+        },
+      },
+      response: {
+        '2xx': {
+          description: 'Team member',
+          content: {
+            'application/json': {
+              schema: {
+                $ref: 'JoinSchemaResponse#/properties',
+              },
+            },
+          },
+        },
+      },
+    },
+    config: {
+      policy: [
+        'authRequired',
+      ],
+    },
+  }, async (request, reply) => {
+    const { hash } = request.params;
+    const { userId } = request;
+    let result: TeamMember | null = null;
+
+    try {
+      result = await noteSettingsService.addUserToTeamByInvitationHash(hash, userId as number);
+    } catch (error: unknown) {
+      const causedError = error as Error;
+
+      return reply.notAcceptable(causedError.message);
+    }
+
+    return reply.send({ result });
+  });
+
+  done();
+};
+
+export default JoinRouter;

src/presentation/http/schema/Join.ts

@@ -0,0 +1,39 @@
+export const JoinSchemaParams = {
+  $id: 'JoinSchemaParams',
+  type: 'object',
+  properties: {
+    hash: {
+      type: 'string',
+      pattern: '[a-zA-Z0-9-_]+',
+      maxLength: 10,
+      minLength: 10,
+    },
+  },
+};
+
+export const JoinSchemaResponse = {
+  $id: 'JoinSchemaResponse',
+  type: 'object',
+  properties: {
+    result: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'number',
+        },
+        noteId: {
+          type: 'string',
+          pattern: '[a-zA-Z0-9-_]+',
+          maxLength: 10,
+          minLength: 10,
+        },
+        userId: {
+          type: 'number',
+        },
+        role: {
+          type: 'number',
+        },
+      },
+    },
+  },
+};

src/repository/noteSettings.repository.ts

@@ -1,7 +1,7 @@
 import type { NoteInternalId } from '@domain/entities/note.js';
 import type NoteSettings from '@domain/entities/noteSettings.js';
 import type NoteSettingsStorage from '@repository/storage/noteSettings.storage.js';
-import type { NoteSettingsCreationAttributes } from '@domain/entities/noteSettings.js';
+import type { InvitationHash, NoteSettingsCreationAttributes } from '@domain/entities/noteSettings.js';
 
 /**
  * Repository allows accessing data from business-logic (domain) level
@@ -31,6 +31,16 @@ export default class NoteSettingsRepository {
     return await this.storage.getNoteSettingsById(id);
   }
 
+  /**
+   * Get note settings by invitation hash
+   *
+   * @param invitationHash - hash for inviting to the note team
+   * @returns { Promise<NoteSettings | null> } - found note settings
+   */
+  public async getNoteSettingsByInvitationHash(invitationHash: InvitationHash): Promise<NoteSettings | null> {
+    return await this.storage.getNoteSettingsByInvitationHash(invitationHash);
+  }
+
   /**
    * Get note settings by note id
    *

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

@@ -3,7 +3,7 @@ import { Model, DataTypes } from 'sequelize';
 import type Orm from '@repository/storage/postgres/orm/sequelize/index.js';
 import { NoteModel } from '@repository/storage/postgres/orm/sequelize/note.js';
 import type NoteSettings from '@domain/entities/noteSettings.js';
-import type { NoteSettingsCreationAttributes } from '@domain/entities/noteSettings.js';
+import type { InvitationHash, NoteSettingsCreationAttributes } from '@domain/entities/noteSettings.js';
 
 /**
  * Class representing a notes settings model in database
@@ -127,6 +127,20 @@ export default class NoteSettingsSequelizeStorage {
     return noteSettings;
   }
 
+  /**
+   * Get note settings by invitation hash
+   *
+   * @param invitationHash - hash for inviting to the note team
+   * @returns { Promise<NoteSettings | null> } - found note settings
+   */
+  public async getNoteSettingsByInvitationHash(invitationHash: InvitationHash): Promise<NoteSettings | null> {
+    return await this.model.findOne({
+      where: {
+        invitationHash,
+      },
+    });
+  }
+
   /**
    * Get note settings
    *