How to access Redis cache store in a custom auth provider ?

[rakshithvikramraj]

I am implementing a custom authentication provider in Medusa v2, using a passwordless approach with phone numbers and OTP-based authentication. Since OTPs need to be stored temporarily, Redis cache seems to be the best option. However, I am unsure how to properly load the Redis connection within the provider. Currently, I have implemented my provider in a certain way, but I am not confident if my approach is correct.

import { AbstractAuthModuleProvider, MedusaError } from "@medusajs/framework/utils"
import { 
  Logger, 
  AuthenticationInput, 
  AuthenticationResponse, 
  AuthIdentityProviderService 
} from "@medusajs/framework/types"
import Redis from "ioredis"

interface InjectedDependencies {
  logger: Logger
}

interface Options {
  redis_connection_url: string
}

class PasswordlessAuthProviderService extends AbstractAuthModuleProvider {
  public static identifier = "passwordless-auth"
  public static DISPLAY_NAME = "Passwordless Auth"

  private readonly logger: Logger
  private readonly options: Options
  private readonly redisClient: Redis

  constructor(
    { logger }: InjectedDependencies,
    options: Options
  ) {
    super()
    this.logger = logger
    this.options = options
    this.redisClient = new Redis(options.redis_connection_url)
  }

  public async register(): Promise<AuthenticationResponse> {
    throw new MedusaError(
      MedusaError.Types.NOT_ALLOWED,
      "Passwordless Auth does not support registration. Use method `authenticate` instead."
    )
  }

  public async authenticate(
    req: AuthenticationInput,
    authIdentityService: AuthIdentityProviderService
  ): Promise<AuthenticationResponse> {
    const { phoneNumber, otp } = req.body ?? {}

    if (!phoneNumber || !otp) {
      return {
        success: false,
        error: "Phone number and OTP are required"
      }
    }

    const isVerified = await this.verifyOTP(`${phoneNumber}-passwordless-auth`, otp)

    if (!isVerified) {
      return {
        success: false,
        error: "Invalid OTP"
      }
    }

    this.clearCache(`${phoneNumber}-passwordless-auth`).then(() => {
      this.closeCache()
    }).catch((error) => {
      this.logger.error(error)
    })
    

    try {
      const { success, authIdentity, error } = await this.upsertAuthIdentity_(
        phoneNumber, 
        authIdentityService
      )
      return {
        success,
        authIdentity,
        error
      }
    } catch (error) {
      this.logger.error(error)
      return {
        success: false,
        error: "Authentication failed"
      }
    }
  }

  private async verifyOTP(phoneNumber: string, otp: string): Promise<boolean> {
    const cachedOTP = await this.redisClient.get(phoneNumber)
    return cachedOTP === otp
  }

  private async clearCache(phoneNumber: string): Promise<void> {
    await this.redisClient.del(phoneNumber)
  }

  // close redis connection
  public async closeCache(): Promise<void> {
    await this.redisClient.quit()
  }

  private async upsertAuthIdentity_(
    phoneNumber: string,
    authIdentityService: AuthIdentityProviderService
  ): Promise<AuthenticationResponse> {

    const metadata: Record<string, unknown> = {
      phoneNumber
    }

    try {
      const authIdentity = await authIdentityService.update(phoneNumber, {
        provider_metadata: metadata,
        user_metadata: metadata
      })

      return { 
        success: true, 
        authIdentity 
      }

    } catch (error) {
      if (error.type === MedusaError.Types.NOT_FOUND) {
        const authIdentity = await authIdentityService.create({
          entity_id: phoneNumber,
          provider_metadata: metadata,
          user_metadata: metadata
        })

        return {
          success: true,
          authIdentity
        }
      }

      return { 
        success: false, 
        error: error.message 
      }
    }
  }
}

export default PasswordlessAuthProviderService

[akordzik]

Have you tried this?
https://docs.medusajs.com/learn/fundamentals/modules/isolation#injecting-dependencies-to-module