Added: GetCurrentApiToken use case

Author: GPortas

src/users/domain/models/ApiTokenInfo.ts

@@ -0,0 +1,4 @@
+export interface ApiTokenInfo {
+  apiToken: string
+  expirationDate: Date
+}

src/users/domain/repositories/IUsersRepository.ts

@@ -1,6 +1,8 @@
+import { ApiTokenInfo } from '../models/ApiTokenInfo'
 import { AuthenticatedUser } from '../models/AuthenticatedUser'
 
 export interface IUsersRepository {
   getCurrentAuthenticatedUser(): Promise<AuthenticatedUser>
   recreateApiToken(): Promise<string>
+  getCurrentApiToken(): Promise<ApiTokenInfo>
 }

src/users/domain/useCases/GetCurrentApiToken.ts

@@ -0,0 +1,20 @@
+import { UseCase } from '../../../core/domain/useCases/UseCase'
+import { ApiTokenInfo } from '../models/ApiTokenInfo'
+import { IUsersRepository } from '../repositories/IUsersRepository'
+
+export class GetCurrentApiToken implements UseCase<ApiTokenInfo> {
+  private usersRepository: IUsersRepository
+
+  constructor(usersRepository: IUsersRepository) {
+    this.usersRepository = usersRepository
+  }
+
+  /**
+   * Returns the current API token information corresponding to the current user authenticated through ApiConfig.
+   *
+   * @returns {Promise<ApiTokenInfo>}
+   */
+  async execute(): Promise<ApiTokenInfo> {
+    return await this.usersRepository.getCurrentApiToken()
+  }
+}

src/users/index.ts

@@ -1,11 +1,13 @@
 import { UsersRepository } from './infra/repositories/UsersRepository'
 import { GetCurrentAuthenticatedUser } from './domain/useCases/GetCurrentAuthenticatedUser'
 import { RecreateApiToken } from './domain/useCases/RecreateApiToken'
+import { GetCurrentApiToken } from './domain/useCases/GetCurrentApiToken'
 
 const usersRepository = new UsersRepository()
 
 const getCurrentAuthenticatedUser = new GetCurrentAuthenticatedUser(usersRepository)
 const recreateApiToken = new RecreateApiToken(usersRepository)
+const getCurrentApiToken = new GetCurrentApiToken(usersRepository)
 
-export { getCurrentAuthenticatedUser, recreateApiToken }
+export { getCurrentAuthenticatedUser, recreateApiToken, getCurrentApiToken }
 export { AuthenticatedUser } from './domain/models/AuthenticatedUser'

src/users/infra/repositories/UsersRepository.ts

@@ -2,6 +2,8 @@ import { ApiRepository } from '../../../core/infra/repositories/ApiRepository'
 import { IUsersRepository } from '../../domain/repositories/IUsersRepository'
 import { AuthenticatedUser } from '../../domain/models/AuthenticatedUser'
 import { AxiosResponse } from 'axios'
+import { ApiTokenInfo } from '../../domain/models/ApiTokenInfo'
+import { transformApiTokenInfoResponseToApiTokenInfo } from './transformers/apiTokenInfoTransformers'
 
 export class UsersRepository extends ApiRepository implements IUsersRepository {
   private readonly usersResourceName: string = 'users'
@@ -22,6 +24,14 @@ export class UsersRepository extends ApiRepository implements IUsersRepository {
       })
   }
 
+  public async getCurrentApiToken(): Promise<ApiTokenInfo> {
+    return this.doGet(`/${this.usersResourceName}/token`, true)
+      .then((response) => transformApiTokenInfoResponseToApiTokenInfo(response))
+      .catch((error) => {
+        throw error
+      })
+  }
+
   private getAuthenticatedUserFromResponse(response: AxiosResponse): AuthenticatedUser {
     const responseData = response.data.data
     return {

src/users/infra/repositories/transformers/apiTokenInfoTransformers.ts

@@ -0,0 +1,14 @@
+import { AxiosResponse } from 'axios'
+import { ApiTokenInfo } from '../../../domain/models/ApiTokenInfo'
+
+export const transformApiTokenInfoResponseToApiTokenInfo = (
+  response: AxiosResponse
+): ApiTokenInfo => {
+  const apiTokenInfoPayload = response.data.data
+  const messageParts = apiTokenInfoPayload.message.split(' ')
+  const expirationDateFormattedTimestamp = `${messageParts[4]}T${messageParts[5]}`
+  return {
+    apiToken: messageParts[1],
+    expirationDate: new Date(expirationDateFormattedTimestamp)
+  }
+}

test/environment/.env

@@ -1,6 +1,6 @@
 POSTGRES_VERSION=13
 DATAVERSE_DB_USER=dataverse
 SOLR_VERSION=9.3.0
-DATAVERSE_IMAGE_REGISTRY=docker.io
-DATAVERSE_IMAGE_TAG=unstable
+DATAVERSE_IMAGE_REGISTRY=ghcr.io
+DATAVERSE_IMAGE_TAG=10857-add-expiration-date-to-recreate-token-api
 DATAVERSE_BOOTSTRAP_TIMEOUT=5m

test/functional/users/GetCurrentApiToken.test.ts

@@ -0,0 +1,19 @@
+import { ApiConfig, getCurrentApiToken } from '../../../src'
+import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
+import { TestConstants } from '../../testHelpers/TestConstants'
+
+describe('execute', () => {
+  beforeAll(async () => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
+  test('should return the current API token', async () => {
+    const actualTokenInfo = await getCurrentApiToken.execute()
+    expect(actualTokenInfo.apiToken).toBe(process.env.TEST_API_KEY)
+    expect(typeof actualTokenInfo.expirationDate).toBe('object')
+  })
+})

test/functional/users/RecreateApiToken.test.ts

@@ -4,6 +4,14 @@ import { TestConstants } from '../../testHelpers/TestConstants'
 import { createApiTokenViaApi } from '../../testHelpers/users/apiTokenHelper'
 
 describe('execute', () => {
+  beforeAll(async () => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
   afterAll(async () => {
     ApiConfig.init(
       TestConstants.TEST_API_URL,

test/integration/users/UsersRepository.test.ts

@@ -52,4 +52,24 @@ describe('UsersRepository', () => {
       await expect(sut.recreateApiToken()).rejects.toThrow(errorExpected)
     })
   })
+
+  describe('getCurrentApiToken', () => {
+    test('should return API token info when valid authentication is provided', async () => {
+      ApiConfig.init(
+        TestConstants.TEST_API_URL,
+        DataverseApiAuthMechanism.API_KEY,
+        process.env.TEST_API_KEY
+      )
+      const actualApiTokenInfo = await sut.getCurrentApiToken()
+      expect(actualApiTokenInfo.apiToken).toBe(process.env.TEST_API_KEY)
+      expect(typeof actualApiTokenInfo.expirationDate).toBe('object')
+    })
+
+    test('should return error when authentication is not valid', async () => {
+      ApiConfig.init(TestConstants.TEST_API_URL, DataverseApiAuthMechanism.API_KEY, 'invalidApiKey')
+
+      const errorExpected: ReadError = new ReadError('[401] Bad API key')
+      await expect(sut.getCurrentApiToken()).rejects.toThrow(errorExpected)
+    })
+  })
 })