feat: rename comment thread into activity (#939)

* feat: rename commentThread into activity server

* feat: rename commentThread into activity front

* feat: migration only create tables


feat: migration only create tables

* Update activities

* fix: rebase partial fix

* fix: all rebase problems and drop activity target alter

* fix: lint

* Update migration

* Update migration

* Fix conflicts

* Fix conflicts

---------

Co-authored-by: Charles Bochet <charles@twenty.com>

server/src/core/activity/activity.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+
+import { ActivityResolver } from './resolvers/activity.resolver';
+import { ActivityService } from './services/activity.service';
+import { ActivityTargetService } from './services/activity-target.service';
+
+@Module({
+  providers: [ActivityResolver, ActivityService, ActivityTargetService],
+  exports: [ActivityService, ActivityTargetService],
+})
+export class ActivityModule {}

server/src/core/activity/resolvers/activity.resolver.spec.ts

@@ -1,19 +1,19 @@
 import { Test, TestingModule } from '@nestjs/testing';
 
-import { CommentThreadService } from 'src/core/comment/services/comment-thread.service';
+import { ActivityService } from 'src/core/activity/services/activity.service';
 import { AbilityFactory } from 'src/ability/ability.factory';
 
-import { CommentThreadResolver } from './comment-thread.resolver';
+import { ActivityResolver } from './activity.resolver';
 
-describe('CommentThreadResolver', () => {
-  let resolver: CommentThreadResolver;
+describe('ActivityResolver', () => {
+  let resolver: ActivityResolver;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
-        CommentThreadResolver,
+        ActivityResolver,
         {
-          provide: CommentThreadService,
+          provide: ActivityService,
           useValue: {},
         },
         {
@@ -23,7 +23,7 @@ describe('CommentThreadResolver', () => {
       ],
     }).compile();
 
-    resolver = module.get<CommentThreadResolver>(CommentThreadResolver);
+    resolver = module.get<ActivityResolver>(ActivityResolver);
   });
 
   it('should be defined', () => {

server/src/core/activity/resolvers/activity.resolver.ts

@@ -0,0 +1,156 @@
+import { Resolver, Args, Mutation, Query } from '@nestjs/graphql';
+import { UseGuards } from '@nestjs/common';
+
+import { accessibleBy } from '@casl/prisma';
+import { Prisma } from '@prisma/client';
+
+import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
+import { AuthWorkspace } from 'src/decorators/auth-workspace.decorator';
+import {
+  PrismaSelector,
+  PrismaSelect,
+} from 'src/decorators/prisma-select.decorator';
+import { AbilityGuard } from 'src/guards/ability.guard';
+import { CheckAbilities } from 'src/decorators/check-abilities.decorator';
+import {
+  CreateActivityAbilityHandler,
+  DeleteActivityAbilityHandler,
+  ReadActivityAbilityHandler,
+  UpdateActivityAbilityHandler,
+} from 'src/ability/handlers/activity.ability-handler';
+import { UserAbility } from 'src/decorators/user-ability.decorator';
+import { AppAbility } from 'src/ability/ability.factory';
+import { AffectedRows } from 'src/core/@generated/prisma/affected-rows.output';
+import { Activity } from 'src/core/@generated/activity/activity.model';
+import { ActivityService } from 'src/core/activity/services/activity.service';
+import { CreateOneActivityArgs } from 'src/core/@generated/activity/create-one-activity.args';
+import { Workspace } from 'src/core/@generated/workspace/workspace.model';
+import { UpdateOneActivityArgs } from 'src/core/@generated/activity/update-one-activity.args';
+import { FindManyActivityArgs } from 'src/core/@generated/activity/find-many-activity.args';
+import { DeleteManyActivityArgs } from 'src/core/@generated/activity/delete-many-activity.args';
+
+@UseGuards(JwtAuthGuard)
+@Resolver(() => Activity)
+export class ActivityResolver {
+  constructor(private readonly activityService: ActivityService) {}
+
+  @Mutation(() => Activity, {
+    nullable: false,
+  })
+  @UseGuards(AbilityGuard)
+  @CheckAbilities(CreateActivityAbilityHandler)
+  async createOneActivity(
+    @Args() args: CreateOneActivityArgs,
+    @AuthWorkspace() workspace: Workspace,
+    @PrismaSelector({ modelName: 'Activity' })
+    prismaSelect: PrismaSelect<'Activity'>,
+  ): Promise<Partial<Activity>> {
+    const createdActivity = await this.activityService.create({
+      data: {
+        ...args.data,
+        ...{ workspace: { connect: { id: workspace.id } } },
+        activityTargets: args.data?.activityTargets?.createMany
+          ? {
+              createMany: {
+                data: args.data.activityTargets.createMany.data.map(
+                  (target) => ({ ...target, workspaceId: workspace.id }),
+                ),
+              },
+            }
+          : undefined,
+      },
+      select: prismaSelect.value,
+    } as Prisma.ActivityCreateArgs);
+
+    return createdActivity;
+  }
+
+  @Mutation(() => Activity, {
+    nullable: false,
+  })
+  @UseGuards(AbilityGuard)
+  @CheckAbilities(UpdateActivityAbilityHandler)
+  async updateOneActivity(
+    @Args() args: UpdateOneActivityArgs,
+    @AuthWorkspace() workspace: Workspace,
+    @PrismaSelector({ modelName: 'Activity' })
+    prismaSelect: PrismaSelect<'Activity'>,
+  ): Promise<Partial<Activity>> {
+    // TODO: Do a proper check with recursion testing on args in a more generic place
+    for (const key in args.data) {
+      if (args.data[key]) {
+        for (const subKey in args.data[key]) {
+          if (JSON.stringify(args.data[key][subKey]) === '{}') {
+            delete args.data[key][subKey];
+          }
+        }
+      }
+
+      if (JSON.stringify(args.data[key]) === '{}') {
+        delete args.data[key];
+      }
+    }
+    const updatedActivity = await this.activityService.update({
+      where: args.where,
+      data: {
+        ...args.data,
+        activityTargets: args.data?.activityTargets
+          ? {
+              createMany: args.data.activityTargets.createMany
+                ? {
+                    data: args.data.activityTargets.createMany.data.map(
+                      (target) => ({
+                        ...target,
+                        workspaceId: workspace.id,
+                      }),
+                    ),
+                  }
+                : undefined,
+              deleteMany: args.data.activityTargets.deleteMany ?? undefined,
+            }
+          : undefined,
+      },
+      select: prismaSelect.value,
+    } as Prisma.ActivityUpdateArgs);
+
+    return updatedActivity;
+  }
+
+  @Query(() => [Activity])
+  @UseGuards(AbilityGuard)
+  @CheckAbilities(ReadActivityAbilityHandler)
+  async findManyActivities(
+    @Args() args: FindManyActivityArgs,
+    @UserAbility() ability: AppAbility,
+    @PrismaSelector({ modelName: 'Activity' })
+    prismaSelect: PrismaSelect<'Activity'>,
+  ): Promise<Partial<Activity>[]> {
+    const result = await this.activityService.findMany({
+      where: {
+        ...args.where,
+        AND: [accessibleBy(ability).Activity],
+      },
+      orderBy: args.orderBy,
+      cursor: args.cursor,
+      take: args.take,
+      skip: args.skip,
+      distinct: args.distinct,
+      select: prismaSelect.value,
+    });
+
+    return result;
+  }
+
+  @Mutation(() => AffectedRows, {
+    nullable: false,
+  })
+  @UseGuards(AbilityGuard)
+  @CheckAbilities(DeleteActivityAbilityHandler)
+  async deleteManyActivities(
+    @Args() args: DeleteManyActivityArgs,
+  ): Promise<AffectedRows> {
+    return this.activityService.deleteMany({
+      where: args.where,
+    });
+  }
+}

server/src/core/activity/services/activity-target.service.spec.ts

@@ -3,15 +3,15 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { PrismaService } from 'src/database/prisma.service';
 import { prismaMock } from 'src/database/client-mock/jest-prisma-singleton';
 
-import { CommentThreadTargetService } from './comment-thread-target.service';
+import { ActivityTargetService } from './activity-target.service';
 
-describe('CommentThreadTargetService', () => {
-  let service: CommentThreadTargetService;
+describe('ActivityTargetService', () => {
+  let service: ActivityTargetService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
-        CommentThreadTargetService,
+        ActivityTargetService,
         {
           provide: PrismaService,
           useValue: prismaMock,
@@ -19,9 +19,7 @@ describe('CommentThreadTargetService', () => {
       ],
     }).compile();
 
-    service = module.get<CommentThreadTargetService>(
-      CommentThreadTargetService,
-    );
+    service = module.get<ActivityTargetService>(ActivityTargetService);
   });
 
   it('should be defined', () => {

server/src/core/activity/services/activity-target.service.ts

@@ -0,0 +1,40 @@
+import { Injectable } from '@nestjs/common';
+
+import { PrismaService } from 'src/database/prisma.service';
+
+@Injectable()
+export class ActivityTargetService {
+  constructor(private readonly prismaService: PrismaService) {}
+
+  // Find
+  findFirst = this.prismaService.client.activityTarget.findFirst;
+  findFirstOrThrow = this.prismaService.client.activityTarget.findFirstOrThrow;
+
+  findUnique = this.prismaService.client.activityTarget.findUnique;
+  findUniqueOrThrow =
+    this.prismaService.client.activityTarget.findUniqueOrThrow;
+
+  findMany = this.prismaService.client.activityTarget.findMany;
+
+  // Create
+  create = this.prismaService.client.activityTarget.create;
+  createMany = this.prismaService.client.activityTarget.createMany;
+
+  // Update
+  update = this.prismaService.client.activityTarget.update;
+  upsert = this.prismaService.client.activityTarget.upsert;
+  updateMany = this.prismaService.client.activityTarget.updateMany;
+
+  // Delete
+  delete = this.prismaService.client.activityTarget.delete;
+  deleteMany = this.prismaService.client.activityTarget.deleteMany;
+
+  // Aggregate
+  aggregate = this.prismaService.client.activityTarget.aggregate;
+
+  // Count
+  count = this.prismaService.client.activityTarget.count;
+
+  // GroupBy
+  groupBy = this.prismaService.client.activityTarget.groupBy;
+}

server/src/core/activity/services/activity.service.spec.ts

@@ -3,15 +3,15 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { PrismaService } from 'src/database/prisma.service';
 import { prismaMock } from 'src/database/client-mock/jest-prisma-singleton';
 
-import { CommentThreadService } from './comment-thread.service';
+import { ActivityService } from './activity.service';
 
-describe('CommentThreadService', () => {
-  let service: CommentThreadService;
+describe('ActivityService', () => {
+  let service: ActivityService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
-        CommentThreadService,
+        ActivityService,
         {
           provide: PrismaService,
           useValue: prismaMock,
@@ -19,7 +19,7 @@ describe('CommentThreadService', () => {
       ],
     }).compile();
 
-    service = module.get<CommentThreadService>(CommentThreadService);
+    service = module.get<ActivityService>(ActivityService);
   });
 
   it('should be defined', () => {

server/src/core/activity/services/activity.service.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@nestjs/common';
+
+import { PrismaService } from 'src/database/prisma.service';
+
+@Injectable()
+export class ActivityService {
+  constructor(private readonly prismaService: PrismaService) {}
+
+  // Find
+  findFirst = this.prismaService.client.activity.findFirst;
+  findFirstOrThrow = this.prismaService.client.activity.findFirstOrThrow;
+
+  findUnique = this.prismaService.client.activity.findUnique;
+  findUniqueOrThrow = this.prismaService.client.activity.findUniqueOrThrow;
+
+  findMany = this.prismaService.client.activity.findMany;
+
+  // Create
+  create = this.prismaService.client.activity.create;
+  createMany = this.prismaService.client.activity.createMany;
+
+  // Update
+  update = this.prismaService.client.activity.update;
+  upsert = this.prismaService.client.activity.upsert;
+  updateMany = this.prismaService.client.activity.updateMany;
+
+  // Delete
+  delete = this.prismaService.client.activity.delete;
+  deleteMany = this.prismaService.client.activity.deleteMany;
+
+  // Aggregate
+  aggregate = this.prismaService.client.activity.aggregate;
+
+  // Count
+  count = this.prismaService.client.activity.count;
+
+  // GroupBy
+  groupBy = this.prismaService.client.activity.groupBy;
+}

server/src/core/comment/comment.module.ts

@@ -1,19 +1,10 @@
 import { Module } from '@nestjs/common';
 
-import { CommentService } from './services/comment.service';
-import { CommentResolver } from './resolvers/comment.resolver';
-import { CommentThreadTargetService } from './services/comment-thread-target.service';
-import { CommentThreadResolver } from './resolvers/comment-thread.resolver';
-import { CommentThreadService } from './services/comment-thread.service';
+import { CommentService } from './comment.service';
+import { CommentResolver } from './comment.resolver';
 
 @Module({
-  providers: [
-    CommentService,
-    CommentThreadService,
-    CommentThreadTargetService,
-    CommentResolver,
-    CommentThreadResolver,
-  ],
-  exports: [CommentService, CommentThreadService, CommentThreadTargetService],
+  providers: [CommentService, CommentResolver],
+  exports: [CommentService],
 })
 export class CommentModule {}

server/src/core/comment/comment.resolver.spec.ts

@@ -1,6 +1,6 @@
 import { Test, TestingModule } from '@nestjs/testing';
 
-import { CommentService } from 'src/core/comment/services/comment.service';
+import { CommentService } from 'src/core/comment/comment.service';
 import { AbilityFactory } from 'src/ability/ability.factory';
 
 import { CommentResolver } from './comment.resolver';

server/src/core/comment/comment.resolver.ts

@@ -8,7 +8,7 @@ import { Workspace } from 'src/core/@generated/workspace/workspace.model';
 import { AuthWorkspace } from 'src/decorators/auth-workspace.decorator';
 import { CreateOneCommentArgs } from 'src/core/@generated/comment/create-one-comment.args';
 import { Comment } from 'src/core/@generated/comment/comment.model';
-import { CommentService } from 'src/core/comment/services/comment.service';
+import { CommentService } from 'src/core/comment/comment.service';
 import {
   PrismaSelector,
   PrismaSelect,

server/src/core/comment/resolvers/comment-thread.resolver.ts

@@ -1,150 +0,0 @@
-import { Resolver, Args, Mutation, Query } from '@nestjs/graphql';
-import { UseGuards } from '@nestjs/common';
-
-import { accessibleBy } from '@casl/prisma';
-import { Prisma } from '@prisma/client';
-
-import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
-import { Workspace } from 'src/core/@generated/workspace/workspace.model';
-import { AuthWorkspace } from 'src/decorators/auth-workspace.decorator';
-import { CommentThread } from 'src/core/@generated/comment-thread/comment-thread.model';
-import { CreateOneCommentThreadArgs } from 'src/core/@generated/comment-thread/create-one-comment-thread.args';
-import { FindManyCommentThreadArgs } from 'src/core/@generated/comment-thread/find-many-comment-thread.args';
-import { CommentThreadService } from 'src/core/comment/services/comment-thread.service';
-import { UpdateOneCommentThreadArgs } from 'src/core/@generated/comment-thread/update-one-comment-thread.args';
-import {
-  PrismaSelector,
-  PrismaSelect,
-} from 'src/decorators/prisma-select.decorator';
-import { AbilityGuard } from 'src/guards/ability.guard';
-import { CheckAbilities } from 'src/decorators/check-abilities.decorator';
-import {
-  CreateCommentThreadAbilityHandler,
-  DeleteCommentThreadAbilityHandler,
-  ReadCommentThreadAbilityHandler,
-  UpdateCommentThreadAbilityHandler,
-} from 'src/ability/handlers/comment-thread.ability-handler';
-import { UserAbility } from 'src/decorators/user-ability.decorator';
-import { AppAbility } from 'src/ability/ability.factory';
-import { AffectedRows } from 'src/core/@generated/prisma/affected-rows.output';
-import { DeleteManyCommentThreadArgs } from 'src/core/@generated/comment-thread/delete-many-comment-thread.args';
-
-@UseGuards(JwtAuthGuard)
-@Resolver(() => CommentThread)
-export class CommentThreadResolver {
-  constructor(private readonly commentThreadService: CommentThreadService) {}
-
-  @Mutation(() => CommentThread, {
-    nullable: false,
-  })
-  @UseGuards(AbilityGuard)
-  @CheckAbilities(CreateCommentThreadAbilityHandler)
-  async createOneCommentThread(
-    @Args() args: CreateOneCommentThreadArgs,
-    @AuthWorkspace() workspace: Workspace,
-    @PrismaSelector({ modelName: 'CommentThread' })
-    prismaSelect: PrismaSelect<'CommentThread'>,
-  ): Promise<Partial<CommentThread>> {
-    const createdCommentThread = await this.commentThreadService.create({
-      data: {
-        ...args.data,
-        ...{ workspace: { connect: { id: workspace.id } } },
-        commentThreadTargets: args.data?.commentThreadTargets?.createMany
-          ? {
-              createMany: {
-                data: args.data.commentThreadTargets.createMany.data.map(
-                  (target) => ({ ...target, workspaceId: workspace.id }),
-                ),
-              },
-            }
-          : undefined,
-      },
-      select: prismaSelect.value,
-    } as Prisma.CommentThreadCreateArgs);
-
-    return createdCommentThread;
-  }
-
-  @Mutation(() => CommentThread, {
-    nullable: false,
-  })
-  @UseGuards(AbilityGuard)
-  @CheckAbilities(UpdateCommentThreadAbilityHandler)
-  async updateOneCommentThread(
-    @Args() args: UpdateOneCommentThreadArgs,
-    @AuthWorkspace() workspace: Workspace,
-    @PrismaSelector({ modelName: 'CommentThread' })
-    prismaSelect: PrismaSelect<'CommentThread'>,
-  ): Promise<Partial<CommentThread>> {
-    // TODO: Do a proper check with recursion testing on args in a more generic place
-    for (const key in args.data) {
-      if (args.data[key]) {
-        for (const subKey in args.data[key]) {
-          if (JSON.stringify(args.data[key][subKey]) === '{}') {
-            delete args.data[key][subKey];
-          }
-        }
-      }
-
-      if (JSON.stringify(args.data[key]) === '{}') {
-        delete args.data[key];
-      }
-    }
-    const updatedCommentThread = await this.commentThreadService.update({
-      where: args.where,
-      data: {
-        ...args.data,
-        commentThreadTargets: args.data?.commentThreadTargets?.createMany
-          ? {
-              createMany: {
-                data: args.data.commentThreadTargets.createMany.data.map(
-                  (target) => ({ ...target, workspaceId: workspace.id }),
-                ),
-              },
-            }
-          : undefined,
-      },
-      select: prismaSelect.value,
-    } as Prisma.CommentThreadUpdateArgs);
-
-    return updatedCommentThread;
-  }
-
-  @Query(() => [CommentThread])
-  @UseGuards(AbilityGuard)
-  @CheckAbilities(ReadCommentThreadAbilityHandler)
-  async findManyCommentThreads(
-    @Args() args: FindManyCommentThreadArgs,
-    @UserAbility() ability: AppAbility,
-    @PrismaSelector({ modelName: 'CommentThread' })
-    prismaSelect: PrismaSelect<'CommentThread'>,
-  ): Promise<Partial<CommentThread>[]> {
-    const result = await this.commentThreadService.findMany({
-      where: {
-        ...args.where,
-        AND: [accessibleBy(ability).CommentThread],
-      },
-      orderBy: args.orderBy,
-      cursor: args.cursor,
-      take: args.take,
-      skip: args.skip,
-      distinct: args.distinct,
-      select: prismaSelect.value,
-    });
-
-    return result;
-  }
-
-  @Mutation(() => AffectedRows, {
-    nullable: false,
-  })
-  @UseGuards(AbilityGuard)
-  @CheckAbilities(DeleteCommentThreadAbilityHandler)
-  async deleteManyCommentThreads(
-    @Args() args: DeleteManyCommentThreadArgs,
-  ): Promise<AffectedRows> {
-    return this.commentThreadService.deleteMany({
-      where: args.where,
-    });
-  }
-}

server/src/core/comment/services/comment-thread-target.service.ts

@@ -1,41 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-import { PrismaService } from 'src/database/prisma.service';
-
-@Injectable()
-export class CommentThreadTargetService {
-  constructor(private readonly prismaService: PrismaService) {}
-
-  // Find
-  findFirst = this.prismaService.client.commentThreadTarget.findFirst;
-  findFirstOrThrow =
-    this.prismaService.client.commentThreadTarget.findFirstOrThrow;
-
-  findUnique = this.prismaService.client.commentThreadTarget.findUnique;
-  findUniqueOrThrow =
-    this.prismaService.client.commentThreadTarget.findUniqueOrThrow;
-
-  findMany = this.prismaService.client.commentThreadTarget.findMany;
-
-  // Create
-  create = this.prismaService.client.commentThreadTarget.create;
-  createMany = this.prismaService.client.commentThreadTarget.createMany;
-
-  // Update
-  update = this.prismaService.client.commentThreadTarget.update;
-  upsert = this.prismaService.client.commentThreadTarget.upsert;
-  updateMany = this.prismaService.client.commentThreadTarget.updateMany;
-
-  // Delete
-  delete = this.prismaService.client.commentThreadTarget.delete;
-  deleteMany = this.prismaService.client.commentThreadTarget.deleteMany;
-
-  // Aggregate
-  aggregate = this.prismaService.client.commentThreadTarget.aggregate;
-
-  // Count
-  count = this.prismaService.client.commentThreadTarget.count;
-
-  // GroupBy
-  groupBy = this.prismaService.client.commentThreadTarget.groupBy;
-}

server/src/core/comment/services/comment-thread.service.ts

@@ -1,39 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-import { PrismaService } from 'src/database/prisma.service';
-
-@Injectable()
-export class CommentThreadService {
-  constructor(private readonly prismaService: PrismaService) {}
-
-  // Find
-  findFirst = this.prismaService.client.commentThread.findFirst;
-  findFirstOrThrow = this.prismaService.client.commentThread.findFirstOrThrow;
-
-  findUnique = this.prismaService.client.commentThread.findUnique;
-  findUniqueOrThrow = this.prismaService.client.commentThread.findUniqueOrThrow;
-
-  findMany = this.prismaService.client.commentThread.findMany;
-
-  // Create
-  create = this.prismaService.client.commentThread.create;
-  createMany = this.prismaService.client.commentThread.createMany;
-
-  // Update
-  update = this.prismaService.client.commentThread.update;
-  upsert = this.prismaService.client.commentThread.upsert;
-  updateMany = this.prismaService.client.commentThread.updateMany;
-
-  // Delete
-  delete = this.prismaService.client.commentThread.delete;
-  deleteMany = this.prismaService.client.commentThread.deleteMany;
-
-  // Aggregate
-  aggregate = this.prismaService.client.commentThread.aggregate;
-
-  // Count
-  count = this.prismaService.client.commentThread.count;
-
-  // GroupBy
-  groupBy = this.prismaService.client.commentThread.groupBy;
-}

server/src/core/company/company-relations.resolver.spec.ts

@@ -1,7 +1,7 @@
 import { Test, TestingModule } from '@nestjs/testing';
 
-import { CommentThreadService } from 'src/core/comment/services/comment-thread.service';
-import { CommentService } from 'src/core/comment/services/comment.service';
+import { CommentService } from 'src/core/comment/comment.service';
+import { ActivityService } from 'src/core/activity/services/activity.service';
 
 import { CompanyRelationsResolver } from './company-relations.resolver';
 import { CompanyService } from './company.service';
@@ -18,7 +18,7 @@ describe('CompanyRelationsResolver', () => {
           useValue: {},
         },
         {
-          provide: CommentThreadService,
+          provide: ActivityService,
           useValue: {},
         },
         {

server/src/core/company/company-relations.resolver.ts

@@ -1,36 +1,36 @@
 import { Resolver, ResolveField, Root, Int } from '@nestjs/graphql';
 
-import { CommentThread } from 'src/core/@generated/comment-thread/comment-thread.model';
 import { Comment } from 'src/core/@generated/comment/comment.model';
 import { Company } from 'src/core/@generated/company/company.model';
-import { CommentThreadService } from 'src/core/comment/services/comment-thread.service';
-import { CommentService } from 'src/core/comment/services/comment.service';
+import { CommentService } from 'src/core/comment/comment.service';
 import {
   PrismaSelect,
   PrismaSelector,
 } from 'src/decorators/prisma-select.decorator';
+import { ActivityService } from 'src/core/activity/services/activity.service';
+import { Activity } from 'src/core/@generated/activity/activity.model';
 
 @Resolver(() => Company)
 export class CompanyRelationsResolver {
   constructor(
-    private readonly commentThreadService: CommentThreadService,
+    private readonly activityService: ActivityService,
     private readonly commentService: CommentService,
   ) {}
 
-  @ResolveField(() => [CommentThread], {
+  @ResolveField(() => [Activity], {
     nullable: false,
   })
-  async commentThreads(
+  async activities(
     @Root() company: Company,
-    @PrismaSelector({ modelName: 'CommentThread' })
-    prismaSelect: PrismaSelect<'CommentThread'>,
-  ): Promise<Partial<CommentThread>[]> {
-    return this.commentThreadService.findMany({
+    @PrismaSelector({ modelName: 'Activity' })
+    prismaSelect: PrismaSelect<'Activity'>,
+  ): Promise<Partial<Activity>[]> {
+    return this.activityService.findMany({
       where: {
-        commentThreadTargets: {
+        activityTargets: {
           some: {
-            commentableId: company.id,
             commentableType: 'Company',
+            commentableId: company.id,
           },
         },
       },
@@ -48,11 +48,11 @@ export class CompanyRelationsResolver {
   ): Promise<Partial<Comment>[]> {
     return this.commentService.findMany({
       where: {
-        commentThread: {
-          commentThreadTargets: {
+        activity: {
+          activityTargets: {
             some: {
-              commentableId: company.id,
               commentableType: 'Company',
+              commentableId: company.id,
             },
           },
         },
@@ -64,13 +64,13 @@ export class CompanyRelationsResolver {
   @ResolveField(() => Int, {
     nullable: false,
   })
-  async _commentThreadCount(@Root() company: Company): Promise<number> {
-    return this.commentThreadService.count({
+  async _activityCount(@Root() company: Company): Promise<number> {
+    return this.activityService.count({
       where: {
-        commentThreadTargets: {
+        activityTargets: {
           some: {
-            commentableId: company.id,
             commentableType: 'Company',
+            commentableId: company.id,
           },
         },
       },

server/src/core/company/company.module.ts

@@ -1,13 +1,14 @@
 import { Module } from '@nestjs/common';
 
 import { CommentModule } from 'src/core/comment/comment.module';
+import { ActivityModule } from 'src/core/activity/activity.module';
 
 import { CompanyService } from './company.service';
 import { CompanyResolver } from './company.resolver';
 import { CompanyRelationsResolver } from './company-relations.resolver';
 
 @Module({
-  imports: [CommentModule],
+  imports: [CommentModule, ActivityModule],
   providers: [CompanyService, CompanyResolver, CompanyRelationsResolver],
   exports: [CompanyService],
 })

server/src/core/core.module.ts

@@ -11,6 +11,7 @@ import { AnalyticsModule } from './analytics/analytics.module';
 import { FileModule } from './file/file.module';
 import { ClientConfigModule } from './client-config/client-config.module';
 import { AttachmentModule } from './attachment/attachment.module';
+import { ActivityModule } from './activity/activity.module';
 import { ViewModule } from './view/view.module';
 
 @Module({
@@ -26,6 +27,7 @@ import { ViewModule } from './view/view.module';
     FileModule,
     ClientConfigModule,
     AttachmentModule,
+    ActivityModule,
     ViewModule,
   ],
   exports: [

server/src/core/person/person-relations.resolver.spec.ts

@@ -1,7 +1,7 @@
 import { Test, TestingModule } from '@nestjs/testing';
 
-import { CommentThreadService } from 'src/core/comment/services/comment-thread.service';
-import { CommentService } from 'src/core/comment/services/comment.service';
+import { CommentService } from 'src/core/comment/comment.service';
+import { ActivityService } from 'src/core/activity/services/activity.service';
 
 import { PersonRelationsResolver } from './person-relations.resolver';
 import { PersonService } from './person.service';
@@ -18,7 +18,7 @@ describe('PersonRelationsResolver', () => {
           useValue: {},
         },
         {
-          provide: CommentThreadService,
+          provide: ActivityService,
           useValue: {},
         },
         {

server/src/core/person/person-relations.resolver.ts

@@ -1,36 +1,36 @@
 import { Resolver, Root, ResolveField, Int } from '@nestjs/graphql';
 
-import { CommentThread } from 'src/core/@generated/comment-thread/comment-thread.model';
 import { Comment } from 'src/core/@generated/comment/comment.model';
 import { Person } from 'src/core/@generated/person/person.model';
-import { CommentThreadService } from 'src/core/comment/services/comment-thread.service';
-import { CommentService } from 'src/core/comment/services/comment.service';
+import { CommentService } from 'src/core/comment/comment.service';
 import {
   PrismaSelect,
   PrismaSelector,
 } from 'src/decorators/prisma-select.decorator';
+import { Activity } from 'src/core/@generated/activity/activity.model';
+import { ActivityService } from 'src/core/activity/services/activity.service';
 
 @Resolver(() => Person)
 export class PersonRelationsResolver {
   constructor(
-    private readonly commentThreadService: CommentThreadService,
+    private readonly activityService: ActivityService,
     private readonly commentService: CommentService,
   ) {}
 
-  @ResolveField(() => [CommentThread], {
+  @ResolveField(() => [Activity], {
     nullable: false,
   })
-  async commentThreads(
+  async activities(
     @Root() person: Person,
-    @PrismaSelector({ modelName: 'CommentThread' })
-    prismaSelect: PrismaSelect<'CommentThread'>,
-  ): Promise<Partial<CommentThread>[]> {
-    return await this.commentThreadService.findMany({
+    @PrismaSelector({ modelName: 'Activity' })
+    prismaSelect: PrismaSelect<'Activity'>,
+  ): Promise<Partial<Activity>[]> {
+    return await this.activityService.findMany({
       where: {
-        commentThreadTargets: {
+        activityTargets: {
           some: {
-            commentableId: person.id,
             commentableType: 'Person',
+            commentableId: person.id,
           },
         },
       },
@@ -48,11 +48,11 @@ export class PersonRelationsResolver {
   ): Promise<Partial<Comment>[]> {
     return this.commentService.findMany({
       where: {
-        commentThread: {
-          commentThreadTargets: {
+        activity: {
+          activityTargets: {
             some: {
-              commentableId: person.id,
               commentableType: 'Person',
+              commentableId: person.id,
             },
           },
         },
@@ -64,13 +64,13 @@ export class PersonRelationsResolver {
   @ResolveField(() => Int, {
     nullable: false,
   })
-  async _commentThreadCount(@Root() person: Person): Promise<number> {
-    return this.commentThreadService.count({
+  async _activityCount(@Root() person: Person): Promise<number> {
+    return this.activityService.count({
       where: {
-        commentThreadTargets: {
+        activityTargets: {
           some: {
-            commentableId: person.id,
             commentableType: 'Person',
+            commentableId: person.id,
           },
         },
       },

server/src/core/person/person.module.ts

@@ -1,13 +1,14 @@
 import { Module } from '@nestjs/common';
 
 import { CommentModule } from 'src/core/comment/comment.module';
+import { ActivityModule } from 'src/core/activity/activity.module';
 
 import { PersonService } from './person.service';
 import { PersonResolver } from './person.resolver';
 import { PersonRelationsResolver } from './person-relations.resolver';
 
 @Module({
-  imports: [CommentModule, CommentModule],
+  imports: [CommentModule, ActivityModule],
   providers: [PersonService, PersonResolver, PersonRelationsResolver],
   exports: [PersonService],
 })

server/src/core/person/person.resolver.ts

@@ -18,7 +18,6 @@ import { UpdateOnePersonArgs } from 'src/core/@generated/person/update-one-perso
 import { CreateOnePersonArgs } from 'src/core/@generated/person/create-one-person.args';
 import { AffectedRows } from 'src/core/@generated/prisma/affected-rows.output';
 import { DeleteManyPersonArgs } from 'src/core/@generated/person/delete-many-person.args';
-import { Workspace } from 'src/core/@generated/workspace/workspace.model';
 import { AuthWorkspace } from 'src/decorators/auth-workspace.decorator';
 import {
   PrismaSelect,
@@ -34,6 +33,7 @@ import {
 } from 'src/ability/handlers/person.ability-handler';
 import { UserAbility } from 'src/decorators/user-ability.decorator';
 import { AppAbility } from 'src/ability/ability.factory';
+import { Workspace } from 'src/core/@generated/workspace/workspace.model';
 
 import { PersonService } from './person.service';
 

server/src/core/workspace/services/workspace.service.ts

@@ -109,11 +109,11 @@ export class WorkspaceService {
       refreshToken,
       attachment,
       comment,
-      commentThreadTarget,
-      commentThread,
+      activityTarget,
+      activity,
     } = this.prismaService.client;
 
-    const commentThreads = await commentThread.findMany({
+    const activitys = await activity.findMany({
       where: { authorId: userId },
     });
 
@@ -142,12 +142,12 @@ export class WorkspaceService {
       comment.deleteMany({
         where,
       }),
-      ...commentThreads.map(({ id: commentThreadId }) =>
-        commentThreadTarget.deleteMany({
-          where: { commentThreadId },
+      ...activitys.map(({ id: activityId }) =>
+        activityTarget.deleteMany({
+          where: { activityId },
         }),
       ),
-      commentThread.deleteMany({
+      activity.deleteMany({
         where,
       }),
       refreshToken.deleteMany({