Complete integration of in-memory cache, and connect with AuthCodeEntity

server/src/index.ts

@@ -1,17 +1,23 @@
-import { db, app, http } from './setup'
+import { db, app, http, cache } from './setup'
 
 interface AuthOptions {
   port: string
 }
 
+export interface Persistence {
+  db: db.DB
+  cache: cache.Cache
+}
+
 const auth = async (options: AuthOptions) => {
-  const { orm, repos } = await db.setupMikroDB()
-  const migrator = orm.getMigrator()
+  const dbRepo = await db.setupMikroDB()
+  const cacheRepo = await cache.setupRedisCache()
+  const migrator = dbRepo.orm.getMigrator()
   await migrator.up()
 
-  const { useCases, controllers } = app.setupApplication(repos)
+  const { useCases, controllers } = app.setupApplication({db: dbRepo, cache: cacheRepo})
 
-  const { webServer } = http.setupAuthExpress(controllers, useCases, { mikroORM: orm })
+  const { webServer } = http.setupAuthExpress(controllers, useCases, { mikroORM: dbRepo.orm })
   webServer.listen(options.port, () => {
     console.log(`LOOLABS AUTH server running on http://localhost:${port}/api/v1 🦆`)
   })

server/src/modules/users/domain/entities/auth-secret/auth-secret.ts

@@ -5,7 +5,8 @@ import { EncryptedClientSecret } from '../../value-objects/encrypted-client-secr
 
 interface AuthSecretProps {
   clientId: string,
-  encryptedClientSecret: EncryptedClientSecret
+  encryptedClientSecret: EncryptedClientSecret,
+  isVerified: boolean
 }
 
 export class AuthSecret extends AggregateRoot<AuthSecretProps> {
@@ -31,4 +32,8 @@ export class AuthSecret extends AggregateRoot<AuthSecretProps> {
   get encryptedClientSecret(): EncryptedClientSecret {
     return this.props.encryptedClientSecret
   }
+
+  get isVerified() :boolean {
+    return this.props.isVerified
+  }
 }

server/src/modules/users/infra/repos/auth-code-repo/implementations/mock-auth-code-repo.ts

@@ -1,5 +1,5 @@
 import { Result } from '../../../../../../shared/core/result'
-import { AuthCodeEntity } from '../../../../../../shared/infra/db/entities/auth-code.entity'
+import { AuthCodeEntity } from '../../../../../../shared/infra/cache/entities/auth-code-entity'
 import { DBError, DBErrors } from '../../../../../../shared/infra/db/errors/errors'
 import { AuthCode } from '../../../../domain/entities/auth-code'
 import { AuthCodeString } from '../../../../domain/value-objects/auth-code'
@@ -26,7 +26,7 @@ export class MockAuthCodeRepo implements AuthCodeRepo {
 
   async save(authCode: AuthCode): Promise<void> {
     const authCodeEntity = await AuthCodeMap.toPersistence(authCode)
-    this.authCodeEntities.set(authCodeEntity.id, authCodeEntity)
+    this.authCodeEntities.set(authCodeEntity.authCodeString, authCodeEntity)
   }
 
   async delete(authCode: AuthCode): Promise<void> {

server/src/modules/users/infra/repos/auth-code-repo/implementations/redis-auth-code-repo.ts

@@ -0,0 +1,30 @@
+import { Result } from '../../../../../../shared/core/result'
+import { AuthCodeEntity } from '../../../../../../shared/infra/cache/entities/auth-code-entity'
+import { RedisRepository } from '../../../../../../shared/infra/cache/redis-repository'
+import { DBError, DBErrors } from '../../../../../../shared/infra/db/errors/errors'
+import { AuthCode } from '../../../../domain/entities/auth-code'
+import { AuthCodeString } from '../../../../domain/value-objects/auth-code'
+import { AuthCodeMap } from '../../../../mappers/auth-code-map'
+import { AuthCodeRepo } from '../auth-code-repo'
+
+export const AUTH_CODE_CACHE_TTL_SECONDS = 300 //5 minutes
+
+export class RedisAuthCodeRepo implements AuthCodeRepo {
+  constructor(protected authCodeEntityRepo: RedisRepository<AuthCodeEntity>) {}
+
+  async getAuthCodeFromAuthCodeString(authCodeString: AuthCodeString): Promise<Result<AuthCode, DBErrors>> {
+    const authCode = await this.authCodeEntityRepo.getEntity(authCodeString.getValue())
+    if (authCode.isErr()) return Result.err(new DBError.AuthSecretNotFoundError(authCodeString.getValue()))
+    return Result.ok(AuthCodeMap.toDomain(authCode.value))
+  }
+
+  async save(authCode: AuthCode): Promise<void> {
+    const authCodeEntity = await AuthCodeMap.toPersistence(authCode)
+    this.authCodeEntityRepo.saveEntity(authCodeEntity, {mode: 'EX', value: AUTH_CODE_CACHE_TTL_SECONDS})
+  }
+
+  async delete(authCode: AuthCode): Promise<void> {
+    const authCodeEntity = await AuthCodeMap.toPersistence(authCode)
+    this.authCodeEntityRepo.removeEntity(authCodeEntity)
+  }
+}

server/src/modules/users/infra/repos/auth-secret-repo/auth-secret-repo.ts

@@ -3,5 +3,7 @@ import { DBErrors } from '../../../../../shared/infra/db/errors/errors'
 import { AuthSecret } from '../../../domain/entities/auth-secret'
 
 export abstract class AuthSecretRepo {
+  abstract exists(clientId: string): Promise<Result<boolean, DBErrors>>
   abstract getAuthSecretByClientId(clientId: string): Promise<Result<AuthSecret, DBErrors>>
+  abstract save(authSecret: AuthSecret): Promise<void>
 }

server/src/modules/users/infra/repos/auth-secret-repo/implementations/mikro-auth-secret-repo.ts

@@ -9,9 +9,30 @@ import { AuthSecretRepo } from '../../auth-secret-repo/auth-secret-repo'
 export class MikroAuthSecretRepo implements AuthSecretRepo {
   constructor(protected authSecretEntityRepo: EntityRepository<AuthSecretEntity>) {}
 
+  async exists(clientId: string): Promise<Result<boolean, DBErrors>> {
+    const authSecretEntity = await this.authSecretEntityRepo.findOne({ 
+      clientId: clientId, 
+    })
+    if(authSecretEntity !== null){
+      return Result.ok(authSecretEntity !== null)
+    } else {
+      return Result.err(new DBError.AuthSecretNotFoundError(clientId))
+    }
+  }
+
   async getAuthSecretByClientId(clientId: string): Promise<Result<AuthSecret, DBErrors>> {
     const authSecret = await this.authSecretEntityRepo.findOne({ clientId: clientId })
     if (authSecret === null) return Result.err(new DBError.AuthSecretNotFoundError(clientId))
     return Result.ok(AuthSecretMap.toDomain(authSecret))
   }
+
+  async save(authSecret: AuthSecret): Promise<void> {
+    const exists = await this.exists(authSecret.clientId)
+
+    if (exists.isOk() && exists.value) return
+
+    const authSecretEntity = await AuthSecretMap.toPersistence(authSecret)
+    this.authSecretEntityRepo.persist(authSecretEntity)
+    this.authSecretEntityRepo.flush()
+  }
 }

server/src/modules/users/infra/repos/auth-secret-repo/implementations/mock-auth-secret-repo.ts

@@ -14,6 +14,13 @@ export class MockAuthSecretRepo implements AuthSecretRepo {
     ))
   }
 
+  async exists(clientId: string): Promise<Result<boolean, DBErrors>> {
+    for (const authSecretEntity of this.authSecretEntities.values()) {
+      if (authSecretEntity.clientId === clientId) return Result.ok(true)
+    }
+    return Result.err(new DBError.AuthSecretNotFoundError(clientId))
+  }
+
   async getAuthSecretByClientId(clientId: string): Promise<Result<AuthSecret, DBErrors>> {
     const authSecretEntity = this.authSecretEntities.get(clientId)
 
@@ -22,4 +29,13 @@ export class MockAuthSecretRepo implements AuthSecretRepo {
     }
     return Result.ok(AuthSecretMap.toDomain(authSecretEntity))
   }
+
+  async save(authSecret: AuthSecret): Promise<void> {
+    const exists = await this.exists(authSecret.clientId)
+    if (exists) return
+
+    const authSecretEntity = await AuthSecretMap.toPersistence(authSecret)
+    this.authSecretEntities.set(authSecretEntity.clientId, authSecretEntity)
+  }
+
 }

server/src/modules/users/mappers/auth-code-map.ts

@@ -1,6 +1,4 @@
-import { UniqueEntityID } from '../../../shared/domain/unique-entity-id'
-import { AuthCodeEntity } from '../../../shared/infra/db/entities/auth-code.entity'
-
+import { AuthCodeEntity } from '../../../shared/infra/cache/entities/auth-code-entity'
 import { AuthCode } from '../domain/entities/auth-code'
 import { AuthCodeString } from '../domain/value-objects/auth-code'
 
@@ -13,8 +11,7 @@ export class AuthCodeMap {
         clientId: authCodeEntity.clientId,
         userId: authCodeEntity.clientId,
         authCodeString: new AuthCodeString(authCodeEntity.authCodeString)
-      },
-      new UniqueEntityID(authCodeEntity.id)
+      }
     )
     if (authCode.isErr()) throw new Error() // TODO: check if we should handle error differently
 

server/src/modules/users/mappers/auth-secret-map.ts

@@ -17,7 +17,8 @@ export class AuthSecretMap {
     const authCodeResult = AuthSecret.create(
       {
         clientId: authSecretEntity.clientId,
-        encryptedClientSecret: encryptedClientSecret.value
+        encryptedClientSecret: encryptedClientSecret.value,
+        isVerified: authSecretEntity.isVerified
       },
       new UniqueEntityID(authSecretEntity.id)
     )
@@ -26,4 +27,13 @@ export class AuthSecretMap {
 
     return authCodeResult.value
   }
+
+  public static async toPersistence(authSecret: AuthSecret): Promise<AuthSecretEntity> {
+    const authSecretEntity = new AuthSecretEntity()
+    authSecretEntity.clientId = authSecret.clientId
+    authSecretEntity.encryptedClientSecret = authSecret.encryptedClientSecret.value
+    authSecretEntity.isVerified = authSecret.isVerified
+
+    return authSecretEntity
+  }
 }

server/src/setup/application/application.ts

@@ -1,10 +1,10 @@
 import { Application } from './types'
-import { Repos } from '../database'
 import { setupControllers } from './controllers'
 import { setupUseCases } from './use-cases'
+import { Persistence } from '../..'
 
-export const setupApplication = (repos: Repos): Application => {
-  const useCases = setupUseCases(repos)
+export const setupApplication = (persistence: Persistence): Application => {
+  const useCases = setupUseCases(persistence)
   const controllers = setupControllers(useCases)
 
   return {

server/src/setup/application/use-cases.ts

@@ -1,18 +1,18 @@
 import { UseCases } from './types'
-import { Repos } from '../database'
 import { CreateUserUseCase } from '../../modules/users/application/use-cases/create-user/create-user-use-case'
 import { LoginUserUseCase } from '../../modules/users/application/use-cases/login-user/login-user-use-case'
 import { PassportUserAuthHandler } from '../../shared/auth/implementations/passport-user-auth-handler'
 import { GetUserUseCase } from '../../modules/users/application/use-cases/get-user/get-user-use-case'
 import { AuthenticateUserUseCase } from '../../modules/users/application/use-cases/authenticate-user/authenticate-user-use-case'
 import { ProtectedUserUseCase } from '../../modules/users/application/use-cases/protected-user/protected-user-use-case'
+import { Persistence } from '../..'
 
-export const setupUseCases = (repos: Repos): UseCases => {
+export const setupUseCases = ({db}: Persistence): UseCases => {
   return {
-    createUser: new CreateUserUseCase(new PassportUserAuthHandler(), repos.user),
+    createUser: new CreateUserUseCase(new PassportUserAuthHandler(), db.repos.user),
     loginUser: new LoginUserUseCase(new PassportUserAuthHandler()),
-    getUser: new GetUserUseCase(repos.user),
-    authUser: new AuthenticateUserUseCase(repos.user),
+    getUser: new GetUserUseCase(db.repos.user),
+    authUser: new AuthenticateUserUseCase(db.repos.user),
     protectedUser: new ProtectedUserUseCase()
   }
 }

server/src/setup/cache/index.ts

@@ -1 +1,4 @@
-export { Client } from './redis'
+export { RedisClient } from './redis'
+export { Repos, Cache } from './types'
+export { RedisEntityRepos, RedisRepos, RedisCache, setupRedisCache } from './redis-cache'
+export { MockEntities, MockRepos, MockDB, setupMockDB } from './mock-cache'

server/src/setup/cache/mock-cache.ts

@@ -0,0 +1,31 @@
+import { AuthCodeRepo } from '../../modules/users/infra/repos/auth-code-repo/auth-code-repo'
+import { MockAuthCodeRepo } from '../../modules/users/infra/repos/auth-code-repo/implementations/mock-auth-code-repo'
+import { AuthCodeEntity } from '../../shared/infra/cache/entities/auth-code-entity'
+import { Repos, Cache } from './types'
+
+
+interface MockEntities {
+  authCodes?: Array<AuthCodeEntity>
+}
+
+interface MockRepos extends Repos {
+  authCode: AuthCodeRepo
+}
+
+const setupMockRepos = (entities: MockEntities): MockRepos => {
+  return {
+    authCode: new MockAuthCodeRepo(entities.authCodes)
+  }
+}
+
+interface MockDB extends Cache {
+  repos: MockRepos
+}
+
+const setupMockDB = (entities: MockEntities): MockDB => {
+  return {
+    repos: setupMockRepos(entities),
+  }
+}
+
+export { MockEntities, MockRepos, MockDB, setupMockDB }

server/src/setup/cache/redis-cache.ts

@@ -0,0 +1,41 @@
+import { RedisAuthCodeRepo } from "../../modules/users/infra/repos/auth-code-repo/implementations/redis-auth-code-repo"
+import { AuthCodeEntity } from "../../shared/infra/cache/entities/auth-code-entity"
+import { RedisRepository } from "../../shared/infra/cache/redis-repository"
+import { Cache, Repos } from "./types"
+
+interface RedisEntityRepos {
+  authCode: RedisRepository<AuthCodeEntity>
+}
+
+const setupRedisEntityRepos = (): RedisEntityRepos => {
+  return {
+    authCode: new RedisRepository<AuthCodeEntity>()
+  }
+}
+
+interface RedisRepos extends Repos {
+  authCode: RedisAuthCodeRepo
+}
+
+const setupRedisRepos = (redisEntityRepos: RedisEntityRepos): RedisRepos => {
+  return {
+    authCode: new RedisAuthCodeRepo(redisEntityRepos.authCode)
+  }
+}
+
+interface RedisCache extends Cache {
+  entityRepos: RedisEntityRepos
+  repos: RedisRepos
+}
+
+const setupRedisCache = async (): Promise<RedisCache> => {
+  const entityRepos = setupRedisEntityRepos()
+  const repos = setupRedisRepos(entityRepos)
+
+  return {
+    entityRepos,
+    repos
+  }
+}
+
+export { RedisEntityRepos, RedisRepos, RedisCache, setupRedisCache }

server/src/setup/cache/redis.ts

@@ -1,6 +1,14 @@
 import redis from 'redis'
 
-export const Client = redis.createClient({
-    url: `${process.env.CACHE_URL}`,
-    password: `${process.env.CACHE_PASSWORD}`
-})
+let redisClient: null | redis.RedisClient = null
+
+export const RedisClient = () =>  {
+  if(redisClient === null){
+    redisClient =  redis.createClient({
+      url: `${process.env.CACHE_URL}`,
+      password: `${process.env.CACHE_PASSWORD}`
+    })
+  }
+  return redisClient
+}
+

server/src/setup/cache/types.ts

@@ -0,0 +1,9 @@
+import { AuthCodeRepo } from '../../modules/users/infra/repos/auth-code-repo/auth-code-repo';
+
+export interface Repos {
+  authCode: AuthCodeRepo
+}
+
+export interface Cache {
+  repos: Repos
+}