add: JwtService and FastifyCookieService in library packages

Author: winverse

apps/server/src/lib/cookie/CookieService.ts

@@ -1,41 +1,11 @@
 import { ENV } from '@env'
-import type { CookieSerializeOptions } from '@fastify/cookie'
-import { FastifyReply } from 'fastify'
+import { FastifyCookieService } from '@packages/library/fastifyCookie'
 import { injectable, singleton } from 'tsyringe'
 
 @injectable()
 @singleton()
-export class CookieService {
-  private get domains() {
-    const isProduction = ENV.appEnv !== 'development'
-    if (isProduction) return ['.velog.io']
-    return ['location', undefined]
-  }
-  public getCookie(reply: FastifyReply, name: string) {
-    return reply.cookies[name]
-  }
-  public setCookie(
-    reply: FastifyReply,
-    name: string,
-    value: string,
-    options?: CookieSerializeOptions,
-  ): void {
-    this.domains.forEach((domain) => {
-      reply.cookie(name, value, {
-        httpOnly: true,
-        domain,
-        path: '/',
-        ...options,
-      })
-    })
-  }
-  public clearCookie(reply: FastifyReply, name: string): void {
-    this.domains.forEach((domain) => {
-      reply.clearCookie(name, {
-        domain,
-        maxAge: 0,
-        httpOnly: true,
-      })
-    })
+export class CookieService extends FastifyCookieService {
+  constructor() {
+    super({ appEnv: ENV.appEnv })
   }
 }

apps/server/src/lib/jwt/JwtService.ts

@@ -1,43 +1,28 @@
-import jwt, { SignOptions } from 'jsonwebtoken'
+import type { SignOptions } from 'jsonwebtoken'
 import { injectable, singleton } from 'tsyringe'
 import { Time } from '@constants/TimeConstants.js'
 import { ENV } from '@env'
 import { DbService } from '@lib/db/DbService.js'
 import { UnauthorizedError } from '@errors/UnauthorizedError.js'
+import { JwtService as JWTService } from '@packages/library/jwt'
+
+interface Service {
+  generateUserToken(userId: string): Promise<{ refreshToken: string; accessToken: string }>
+  refreshUserToken(
+    userId: string,
+    tokenId: string,
+    refreshTokenExp: number,
+    originalRefreshToken: string,
+  ): Promise<{ accessToken: string; refreshToken: string }>
+  generateToken(payload: string | Buffer | Record<any, any>, options?: SignOptions): Promise<string>
+  decodeToken<T = unknown>(token: string): Promise<T>
+}
 
 @injectable()
 @singleton()
-export class JwtService {
-  constructor(private readonly db: DbService) {}
-  public generateToken(
-    payload: string | Buffer | Record<any, any>,
-    options?: SignOptions,
-  ): Promise<string> {
-    const jwtOptions: SignOptions = {
-      issuer: 'velog.io',
-      expiresIn: '7d',
-      ...options,
-    }
-
-    if (!jwtOptions.expiresIn) {
-      // removes expiresIn when expiresIn is given as undefined
-      delete jwtOptions.expiresIn
-    }
-    return new Promise((resolve, reject) => {
-      if (!ENV.jwtSecretKey) return
-      jwt.sign(payload, ENV.jwtSecretKey, jwtOptions, (err, token) => {
-        if (err) reject(err)
-        resolve(token as string)
-      })
-    })
-  }
-  public decodeToken<T = unknown>(token: string): Promise<T> {
-    return new Promise((resolve, reject) => {
-      jwt.verify(token, ENV.jwtSecretKey, (err, decoded) => {
-        if (err) reject(err)
-        resolve(decoded as T)
-      })
-    })
+export class JwtService extends JWTService implements Service {
+  constructor(private readonly db: DbService) {
+    super({ secretKey: ENV.jwtSecretKey })
   }
   public async generateUserToken(userId: string) {
     const authToken = await this.db.authToken.create({

packages/library/src/fastifyCookie/FastifyCookie.test.mts

@@ -0,0 +1,9 @@
+import { container } from 'tsyringe'
+import { FastifyCookieService } from './FastifyCookieService.mjs'
+
+describe('FastifyCookieService', () => {
+  const service = container.resolve(FastifyCookieService)
+  it('should be defined', () => {
+    expect(service).toBeDefined()
+  })
+})

packages/library/src/fastifyCookie/FastifyCookieService.mts

@@ -0,0 +1,56 @@
+import type { CookieSerializeOptions } from '@fastify/cookie'
+import { FastifyReply } from 'fastify'
+
+interface Service {
+  setCookie(
+    reply: FastifyReply,
+    name: string,
+    value: string,
+    options?: CookieSerializeOptions,
+  ): void
+  getCookie(reply: FastifyReply, name: string): string | undefined
+  clearCookie(reply: FastifyReply, name: string): void
+}
+
+type Params = {
+  appEnv: 'development' | 'stage' | 'production'
+}
+
+export class FastifyCookieService implements Service {
+  private appEnv!: 'development' | 'stage' | 'production'
+  constructor({ appEnv }: Params) {
+    this.appEnv = appEnv
+  }
+  public setCookie(
+    reply: FastifyReply,
+    name: string,
+    value: string,
+    options?: CookieSerializeOptions,
+  ): void {
+    this.domains.forEach((domain) => {
+      reply.cookie(name, value, {
+        httpOnly: true,
+        domain,
+        path: '/',
+        ...options,
+      })
+    })
+  }
+  public getCookie(reply: FastifyReply, name: string) {
+    return reply.cookies[name]
+  }
+  public clearCookie(reply: FastifyReply, name: string): void {
+    this.domains.forEach((domain) => {
+      reply.clearCookie(name, {
+        domain,
+        maxAge: 0,
+        httpOnly: true,
+      })
+    })
+  }
+  private get domains() {
+    const isProduction = this.appEnv !== 'development'
+    if (isProduction) return ['.velog.io']
+    return ['location', undefined]
+  }
+}

packages/library/src/jwt/Jwt.test.mts

@@ -0,0 +1,9 @@
+import { container } from 'tsyringe'
+import { JwtService } from './JwtService.mjs'
+
+describe('JwtService', () => {
+  const service = container.resolve(JwtService)
+  it('should be defined', () => {
+    expect(service).toBeDefined()
+  })
+})

packages/library/src/jwt/JwtService.mts

@@ -0,0 +1,47 @@
+import jwt, { SignOptions } from 'jsonwebtoken'
+
+interface Service {
+  generateToken(payload: string | Buffer | Record<any, any>, options?: SignOptions): Promise<string>
+  decodeToken<T = unknown>(token: string): Promise<T>
+}
+
+type Params = {
+  secretKey: string
+}
+
+export class JwtService implements Service {
+  private secretKey!: string
+  constructor({ secretKey }: Params) {
+    this.secretKey = secretKey
+  }
+  public generateToken(
+    payload: string | Buffer | Record<any, any>,
+    options?: SignOptions,
+  ): Promise<string> {
+    const jwtOptions: SignOptions = {
+      issuer: 'velog.io',
+      expiresIn: '7d',
+      ...options,
+    }
+
+    if (!jwtOptions.expiresIn) {
+      // removes expiresIn when expiresIn is given as undefined
+      delete jwtOptions.expiresIn
+    }
+
+    return new Promise((resolve, reject) => {
+      jwt.sign(payload, this.secretKey, jwtOptions, (err, token) => {
+        if (err) reject(err)
+        resolve(token as string)
+      })
+    })
+  }
+  public decodeToken<T = unknown>(token: string): Promise<T> {
+    return new Promise((resolve, reject) => {
+      jwt.verify(token, this.secretKey, (err, decoded) => {
+        if (err) reject(err)
+        resolve(decoded as T)
+      })
+    })
+  }
+}