Feature/user setting

.vscode/settings.json

@@ -52,5 +52,6 @@
   "C_Cpp_Runner.useLeakSanitizer": false,
   "C_Cpp_Runner.showCompilationTime": false,
   "C_Cpp_Runner.useLinkTimeOptimization": false,
-  "C_Cpp_Runner.msvcSecureNoWarnings": false
+  "C_Cpp_Runner.msvcSecureNoWarnings": false,
+  "workbench.colorCustomizations": {}
 }

package.json

@@ -24,7 +24,8 @@
     "email": "[email protected]"
   },
   "keywords": [
-    "velog"
+    "velog",
+    "blog"
   ],
   "devDependencies": {
     "husky": "^8.0.0",

packages/velog-cron/src/common/errors/BadRequestErrors.ts

@@ -2,6 +2,6 @@ import { HttpError } from './HttpError.js'
 
 export class BadRequestError extends HttpError {
   constructor(message = 'BAD_REQUEST') {
-    super(message, 400, 'BadRequest')
+    super('bad request', message, 400)
   }
 }

packages/velog-cron/src/common/errors/ConfilctError.ts

@@ -2,6 +2,6 @@ import { HttpError } from './HttpError.js'
 
 export class ConfilctError extends HttpError {
   constructor(message = 'CONFILCT') {
-    super(message, 409, 'Confilct')
+    super('confilct', message, 409)
   }
 }

packages/velog-cron/src/common/errors/ForbiddenError.ts

@@ -2,6 +2,6 @@ import { HttpError } from './HttpError.js'
 
 export class ForbiddenError extends HttpError {
   constructor(message = 'FORBIDDEN') {
-    super(message, 403, 'Forbidden')
+    super('forbidden', message, 403)
   }
 }

packages/velog-cron/src/common/errors/HttpError.ts

@@ -2,7 +2,7 @@ export class HttpError extends Error {
   message
   statusCode
   name
-  constructor(message: string, statusCode: number, name: string) {
+  constructor(name: string, message: string, statusCode: number) {
     super()
     this.message = message
     this.statusCode = statusCode

packages/velog-cron/src/common/errors/NotfoundError.ts

@@ -2,6 +2,6 @@ import { HttpError } from './HttpError.js'
 
 export class NotFoundError extends HttpError {
   constructor(message = 'NOT_FOUND') {
-    super(message, 404, 'NotFound')
+    super('not found', message, 404)
   }
 }

packages/velog-cron/src/common/errors/UnauthorizedError.ts

@@ -2,6 +2,6 @@ import { HttpError } from './HttpError.js'
 
 export class UnauthorizedError extends HttpError {
   constructor(message = 'Unauthorized') {
-    super(message, 401, 'Unauthorized')
+    super('unauthorized', message, 401)
   }
 }

packages/velog-cron/src/common/plugins/globals/cronPlugin.ts

@@ -18,7 +18,6 @@ const cronPlugin: FastifyPluginCallback = async (fastfiy, opts, done) => {
       name: 'generate trending writers every day',
       cronTime: '0 5 * * *', // every day at 05:00 (5:00 AM)
       jobService: generateTrendingWritersJob,
-      param: undefined,
     },
     {
       name: 'posts score calculation in every day',
@@ -30,13 +29,11 @@ const cronPlugin: FastifyPluginCallback = async (fastfiy, opts, done) => {
       name: 'delete feed in every hour',
       cronTime: '10 * * * *', // every hour at 10 minutes
       jobService: deleteFeedJob,
-      param: undefined,
     },
     {
       name: 'generate feeds in every 1 minute',
       cronTime: '*/1 * * * *', // every 1 minute
       jobService: generateFeedJob,
-      param: undefined,
     },
     {
       name: 'posts score calculation in every 5 minutes',
@@ -55,23 +52,27 @@ const cronPlugin: FastifyPluginCallback = async (fastfiy, opts, done) => {
     })
   }
 
-  // for test
-  if (ENV.dockerEnv !== 'production') {
-    const immediateRunJobs = jobDescription.filter((job) => !!job.isImmediate)
-    await Promise.all(immediateRunJobs.map(createTick))
+  try {
+    // for Test
+    if (ENV.dockerEnv !== 'production') {
+      const immediateRunJobs = jobDescription.filter((job) => !!job.isImmediateExecute)
+      await Promise.all(immediateRunJobs.map(createTick))
+    }
+
+    if (ENV.dockerEnv === 'production') {
+      const crons = jobDescription.map(createJob)
+      await Promise.all(
+        crons.map((cron) => {
+          console.log(`${cron.name} is registered`)
+          cron.start()
+        }),
+      )
+    }
+  } catch (error) {
+    console.error('Error initializing cron jobs:', error)
+  } finally {
+    done()
   }
-
-  if (ENV.dockerEnv === 'production') {
-    const crons = jobDescription.map(createJob)
-    await Promise.all(
-      crons.map((cron) => {
-        console.log(`${cron.name} is registered`)
-        cron.start()
-      }),
-    )
-  }
-
-  done()
 }
 
 export default cronPlugin
@@ -93,16 +94,16 @@ type JobDescription = NeedParamJobService | NotNeedParamJobService
 type NeedParamJobService = {
   name: string
   cronTime: string
-  param: number
-  isImmediate?: boolean
+  param: any
+  isImmediateExecute?: boolean
   jobService: CalculatePostScoreJob
 }
 
 type NotNeedParamJobService = {
   name: string
   cronTime: string
-  param: undefined
-  isImmediate?: boolean
+  param?: undefined
+  isImmediateExecute?: boolean
   jobService: GenerateFeedJob | GenerateTrendingWritersJob | DeleteFeedJob
 }
 

packages/velog-cron/src/services/FeedService/index.ts

@@ -1,5 +1,7 @@
 import { DbService } from '@lib/db/DbService.js'
+import { UtilsService } from '@lib/utils/UtilsService'
 import { FollowUserService } from '@services/FollowUserService/index.js'
+import { subHours } from 'date-fns'
 
 import { injectable, singleton } from 'tsyringe'
 
@@ -12,6 +14,7 @@ interface Service {
 export class FeedService implements Service {
   constructor(
     private readonly db: DbService,
+    private readonly utils: UtilsService,
     private readonly followUserService: FollowUserService,
   ) {}
   public async createFeed({ followingId, postId }: CreateFeedArgs): Promise<void> {
@@ -32,6 +35,9 @@ export class FeedService implements Service {
     return await this.db.feed.deleteMany({
       where: {
         is_deleted: true,
+        created_at: {
+          lte: subHours(this.utils.now, 1),
+        },
       },
     })
   }

packages/velog-scripts/.eslintrc.cjs

@@ -0,0 +1,25 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: './tsconfig.json',
+    sourceType: 'module',
+    tsconfigRootDir: __dirname,
+  },
+  plugins: ['@typescript-eslint', 'prettier'],
+  extends: ['plugin:@typescript-eslint/recommended', 'plugin:prettier/recommended'],
+  root: true,
+  env: {
+    node: true,
+    jest: true,
+  },
+  rules: {
+    'prettier/prettier': ['error', { semi: false, singleQuote: true }],
+    '@typescript-eslint/interface-name-prefix': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/no-non-null-assertion': 'off',
+    '@typescript-eslint/no-empty-interface': 'off',
+    '@typescript-eslint/no-unused-vars': ['error', { ignoreRestSiblings: true }],
+  },
+}

packages/velog-scripts/.gitignore

@@ -0,0 +1,4 @@
+/prisma
+
+/data/*
+!/data/.gitkeep

packages/velog-scripts/env/.env.example

@@ -0,0 +1,5 @@
+DATABASE_URL=
+DISCORD_BOT_TOKEN=
+DISCORD_PRIVATE_POSTS_CHANNEL_ID=
+REDIS_HOST=
+SPAM_ACCOUNT_DISPLAY_NAME=

packages/velog-scripts/env/env.mts

@@ -0,0 +1,27 @@
+import { z } from 'zod'
+import dotenv from 'dotenv'
+import path from 'path'
+
+if (process.env.NODE_ENV === 'production') {
+  throw new Error('This Script only allowed in Development environment')
+}
+
+dotenv.config({ path: path.resolve(process.cwd(), '.env') })
+
+const env = z.object({
+  spamAccountDisplayName: z.array(z.string()).min(1),
+  databaseUrl: z.string(),
+  discordBotToken: z.string(),
+  discordPrivatePostsChannelId: z.string(),
+  redisHost: z.string(),
+  restorePostsUsername: z.string().optional(),
+})
+
+export const ENV = env.parse({
+  spamAccountDisplayName: (process.env.SPAM_ACCOUNT_DISPLAY_NAME ?? '')?.split(',').filter(Boolean),
+  databaseUrl: process.env.DATABASE_URL,
+  discordBotToken: process.env.DISCORD_BOT_TOKEN,
+  discordPrivatePostsChannelId: process.env.DISCORD_PRIVATE_POSTS_CHANNEL_ID,
+  redisHost: process.env.REDIS_HOST,
+  restorePostsUsername: process.env.RESTORE_POSTS_USERNAME,
+})

packages/velog-scripts/lib/db/DbService.mts

@@ -0,0 +1,6 @@
+import { PrismaClient } from '@prisma/client'
+import { injectable, singleton } from 'tsyringe'
+
+@injectable()
+@singleton()
+export class DbService extends PrismaClient {}

packages/velog-scripts/lib/discord/DiscordService.mts

@@ -0,0 +1,47 @@
+import { injectable, singleton } from 'tsyringe'
+import { Client, GatewayIntentBits } from 'discord.js'
+import { ENV } from '../../env/env.mjs'
+
+@injectable()
+@singleton()
+export class DiscordService {
+  private client!: Client
+  construct() {}
+  public connection(): Promise<Client> {
+    return new Promise((resolve) => {
+      this.client = new Client({
+        intents: [GatewayIntentBits.MessageContent],
+      })
+
+      this.client.on('ready', () => {
+        console.log('Discord Client ready!')
+        resolve(this.client)
+      })
+
+      this.client.login(ENV.discordBotToken)
+    })
+  }
+  public sendMessage(channelId: string, message: string) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const isReady = this.client.isReady()
+
+        if (!isReady) {
+          throw new Error('Discord bot is not ready')
+        }
+
+        const channel = await this.client.channels.fetch(channelId)
+
+        if (channel?.isTextBased()) {
+          await channel.send(message)
+        } else {
+          throw new Error('Wrong channel type')
+        }
+        resolve('Message sent successfully!')
+      } catch (error) {
+        reject('Failed to send meesage')
+        throw error
+      }
+    })
+  }
+}

packages/velog-scripts/lib/redis/RedisService.mts

@@ -0,0 +1,51 @@
+import { injectable, singleton } from 'tsyringe'
+import Redis from 'ioredis'
+import { ENV } from '../../env/env.mjs'
+
+interface Service {
+  get setName(): SetName
+}
+
+@injectable()
+@singleton()
+export class RedisService extends Redis implements Service {
+  constructor() {
+    super({ port: 6379, host: ENV.redisHost })
+  }
+
+  async connection(): Promise<string> {
+    return new Promise((resolve) => {
+      this.connect(() => {
+        resolve(`Redis connection established to ${ENV.redisHost}`)
+      })
+    })
+  }
+
+  get setName() {
+    return {
+      blockList: 'set:blockList',
+    }
+  }
+
+  public async addBlockList(username: string) {
+    try {
+      const keyname = this.setName.blockList
+      await this.sadd(keyname, username)
+    } catch (error) {
+      throw error
+    }
+  }
+
+  public async readBlockList() {
+    try {
+      const keyname = this.setName.blockList
+      return await this.smembers(keyname)
+    } catch (error) {
+      throw error
+    }
+  }
+}
+
+type SetName = {
+  blockList: string
+}