feat ✨ follow api 추가

app/package.json

@@ -43,6 +43,7 @@
     "graphql": "^16.8.1",
     "graphql-query-complexity": "^0.12.0",
     "graphql-scalars": "^1.22.2",
+    "graphql-subscriptions": "^2.0.0",
     "lru-cache": "^10.0.0",
     "mongoose": "^7.3.3",
     "reflect-metadata": "^0.1.13",

app/src/api/cursusUser/cursusUser.cache.service.ts

@@ -9,6 +9,7 @@ import {
   CacheUtilService,
   type UserFullProfileMap,
 } from 'src/cache/cache.util.service';
+import { UserPreview } from 'src/common/models/common.user.model';
 import { DateTemplate } from 'src/dateRange/dtos/dateRange.dto';
 import { CursusUserService } from './cursusUser.service';
 
@@ -32,6 +33,22 @@ export class CursusUserCacheService {
     private readonly cacheUtilRankingService: CacheUtilRankingService,
   ) {}
 
+  async getUserPreview(userId: number): Promise<UserPreview | undefined> {
+    const userFullProfile = await this.getUserFullProfile(userId);
+
+    const cursusUserProfile = userFullProfile?.cursusUser.user;
+
+    if (!cursusUserProfile) {
+      return undefined;
+    }
+
+    return {
+      id: cursusUserProfile.id,
+      login: cursusUserProfile.login,
+      imgUrl: cursusUserProfile.image.link,
+    };
+  }
+
   async getUserFullProfile(
     userId: number,
   ): Promise<UserFullProfileCache | undefined> {

app/src/api/cursusUser/cursusUser.service.ts

@@ -77,6 +77,20 @@ export class CursusUserService {
     return this.cursusUserModel.aggregate<ReturnType>();
   }
 
+  async getuserIdByLogin(login: string): Promise<number | null> {
+    const cursusUser: { user: Pick<cursus_user['user'], 'id'> } | null =
+      await this.findOneAndLean({
+        filter: { 'user.login': login },
+        select: { 'user.id': 1 },
+      });
+
+    if (!cursusUser) {
+      return null;
+    }
+
+    return cursusUser.user.id;
+  }
+
   async findAllAndLean(
     queryArgs?: QueryArgs<cursus_user>,
   ): Promise<cursus_user[]> {

app/src/app.module.ts

@@ -19,6 +19,7 @@ import { JWT_CONFIG } from './config/jwt';
 import { RUNTIME_CONFIG } from './config/runtime';
 import { MongooseRootModule } from './database/mongoose/database.mongoose.module';
 import { DateWrapper } from './dateWrapper/dateWrapper';
+import { FollowModule } from './follow/follow.module';
 import { HealthCheckModule } from './healthcheck/healthcheck.module';
 import { LambdaModule } from './lambda/lambda.module';
 import { LoginModule } from './login/login.module';
@@ -74,6 +75,14 @@ import { TeamInfoModule } from './page/teamInfo/teamInfo.module';
             numberScalarMode: 'integer',
           },
           autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
+          subscriptions: {
+            'graphql-ws': {
+              path: '/graphql',
+            },
+            'subscriptions-transport-ws': {
+              path: '/graphql',
+            },
+          },
         };
       },
     }),
@@ -97,6 +106,7 @@ export class AppRootModule {}
     EvalLogModule,
     SettingModule,
     CalculatorModule,
+    FollowModule,
     LambdaModule,
     HealthCheckModule,
     CacheDecoratorOnReturnModule,

app/src/follow/db/follow.database.schema.ts

@@ -0,0 +1,18 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+
+export type UserDocument = HydratedDocument<follow>;
+
+@Schema({ collection: 'follows' })
+export class follow {
+  @Prop({ required: true })
+  userId: number;
+
+  @Prop({ required: true })
+  followId: number;
+
+  @Prop({ required: true })
+  followAt: Date;
+}
+
+export const FollowSchema = SchemaFactory.createForClass(follow);

app/src/follow/dto/follow.dto.ts

@@ -0,0 +1,20 @@
+import { ArgsType, Field, registerEnumType } from '@nestjs/graphql';
+import { PaginationIndexArgs } from 'src/pagination/index/dtos/pagination.index.dto.args';
+
+export enum FollowSortOrder {
+  FOLLOW_AT_ASC,
+  FOLLOW_AT_DESC,
+}
+
+registerEnumType(FollowSortOrder, { name: 'FollowSortOrder' });
+
+@ArgsType()
+export class FollowPaginatedArgs extends PaginationIndexArgs {
+  @Field()
+  targetId: number;
+
+  @Field((_type) => FollowSortOrder, {
+    defaultValue: FollowSortOrder.FOLLOW_AT_DESC,
+  })
+  sortOrder: FollowSortOrder;
+}

app/src/follow/follow.cache.service.ts

@@ -0,0 +1,40 @@
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Inject, Injectable } from '@nestjs/common';
+import { CacheUtilService } from 'src/cache/cache.util.service';
+import { Follow } from './model/follow.model';
+
+export const FOLLOW_LISTS = 'followLists';
+
+@Injectable()
+export class FollowCacheService {
+  constructor(
+    @Inject(CACHE_MANAGER)
+    private readonly cacheUtilService: CacheUtilService,
+  ) {}
+
+  async set({
+    id,
+    type,
+    list,
+  }: {
+    id: number;
+    type: 'follower' | 'following';
+    list: Follow[];
+  }): Promise<void> {
+    const key = `${id}:${type}:${FOLLOW_LISTS}`;
+
+    await this.cacheUtilService.set(key, list, 0);
+  }
+
+  async get(userId: number, type: 'follower' | 'following'): Promise<Follow[]> {
+    const key = `${userId}:${type}:${FOLLOW_LISTS}`;
+
+    const cachedData = await this.cacheUtilService.get<Follow[]>(key);
+
+    if (!cachedData) {
+      return []; //todo: 흠,,,
+    }
+
+    return cachedData;
+  }
+}

app/src/follow/follow.module.ts

@@ -0,0 +1,22 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { CursusUserModule } from 'src/api/cursusUser/cursusUser.module';
+import { CacheUtilModule } from 'src/cache/cache.util.module';
+import { PaginationIndexModule } from 'src/pagination/index/pagination.index.module';
+import { FollowSchema, follow } from './db/follow.database.schema';
+import { FollowCacheService } from './follow.cache.service';
+import { FollowResolver } from './follow.resolver';
+import { FollowService } from './follow.service';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: follow.name, schema: FollowSchema }]),
+    CursusUserModule,
+    PaginationIndexModule,
+    CacheUtilModule,
+  ],
+  providers: [FollowResolver, FollowService, FollowCacheService],
+  exports: [FollowService, FollowCacheService],
+})
+// eslint-disable-next-line
+export class FollowModule {}

app/src/follow/follow.resolver.ts

@@ -0,0 +1,89 @@
+import { NotFoundException, UseFilters, UseGuards } from '@nestjs/common';
+import { Args, Mutation, Query, Resolver, Subscription } from '@nestjs/graphql';
+import { PubSub } from 'graphql-subscriptions';
+import { MyUserId } from 'src/auth/myContext';
+import { StatAuthGuard } from 'src/auth/statAuthGuard';
+import { HttpExceptionFilter } from 'src/http-exception.filter';
+import { FollowPaginatedArgs } from './dto/follow.dto';
+import { FollowService } from './follow.service';
+import { FollowSuccess, MyFollowPaginated } from './model/follow.model';
+
+const pubSub = new PubSub();
+
+@UseFilters(HttpExceptionFilter)
+@Resolver()
+export class FollowResolver {
+  constructor(private readonly followService: FollowService) {}
+
+  @Subscription((_returns) => FollowSuccess, { name: 'followUpdated' })
+  followUpdated() {
+    return pubSub.asyncIterator('followUpdated');
+  }
+
+  @UseGuards(StatAuthGuard)
+  @Mutation((_returns) => FollowSuccess)
+  async followUser(
+    @MyUserId() userId: number,
+    @Args('targetId') targetId: number,
+  ): Promise<FollowSuccess> {
+    try {
+      const followResult = await this.followService.followUser(
+        userId,
+        targetId,
+      );
+
+      await pubSub.publish('followUpdated', { followUpdated: followResult });
+
+      return followResult;
+    } catch (e) {
+      throw new NotFoundException();
+    }
+  }
+
+  @UseGuards(StatAuthGuard)
+  @Mutation((_returns) => FollowSuccess)
+  async unfollowUser(
+    @MyUserId() userId: number,
+    @Args('targetId') targetId: number,
+  ): Promise<FollowSuccess> {
+    try {
+      const followResult = await this.followService.unfollowUser(
+        userId,
+        targetId,
+      );
+
+      await pubSub.publish('followUpdated', { followUpdated: followResult });
+
+      return followResult;
+    } catch (e) {
+      throw new NotFoundException();
+    }
+  }
+
+  @UseGuards(StatAuthGuard)
+  @Query((_returns) => Boolean)
+  async getIsFollowing(
+    @MyUserId() userId: number,
+    @Args('targetId') targetId: number,
+  ): Promise<boolean> {
+    return await this.followService.isFollowing(userId, targetId);
+  }
+
+  @UseGuards(StatAuthGuard)
+  @Query((_returns) => MyFollowPaginated)
+  async getFollowerPaginated(
+    @MyUserId() userId: number,
+    @Args() args: FollowPaginatedArgs,
+  ): Promise<MyFollowPaginated> {
+    return await this.followService.followerPaginated(userId, args);
+  }
+
+  @UseGuards(StatAuthGuard)
+  @Query((_returns) => MyFollowPaginated)
+  async getFollowingPaginated(
+    @MyUserId() userId: number,
+    @Args() args: FollowPaginatedArgs,
+  ): Promise<MyFollowPaginated> {
+    return await this.followService.followingPaginated(userId, args);
+  }
+}