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

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

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

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

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

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

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;
+}