@novo-learning/novo-sdk/src/clients/exercise-api/exercise-api.ts

SDK for the Novolanguage Speech Analysis API

import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
import { ExerciseType, LanguageCode } from '../../entities';
import { ExerciseDefinitionMapper } from '../../mappers/exercise-definition.mapper';
import { ExerciseTypeMapper } from '../../mappers/exercise-type.mapper';
import { LanguageCodeMapper } from '../../mappers/language-code.mapper';
import { CreateExerciseDtoV1 } from './dto/create-exercise.dto.v1';
import { ExerciseDescriptorDtoV1 } from './dto/exercise-descriptor.dto.v1';
import { ExerciseResponseDtoV1 } from './dto/exercise-response.dto.v1';
import { ReplaceExerciseDtoV1 } from './dto/replace-exercise.dto.v1';
import {
  Configuration,
  ExerciseResponseDtoV1 as GeneratedExerciseResponseDtoV1,
  ExercisesApi as GeneratedExercisesApi,
} from './generated';

export class ExerciseApi {
  private readonly api: GeneratedExercisesApi;
  private readonly languageCodeMapper: LanguageCodeMapper;
  private readonly exerciseTypeMapper: ExerciseTypeMapper;
  private readonly exerciseDefinitionMapper: ExerciseDefinitionMapper;

  constructor(configuration?: Configuration | undefined, basePath?: string, axios?: AxiosInstance) {
    this.api = new GeneratedExercisesApi(configuration, basePath, axios);
    this.languageCodeMapper = new LanguageCodeMapper();
    this.exerciseTypeMapper = new ExerciseTypeMapper();
    this.exerciseDefinitionMapper = new ExerciseDefinitionMapper();
  }

  private mapGeneratedExerciseResponse(
    dto: AxiosResponse<GeneratedExerciseResponseDtoV1>,
  ): AxiosResponse<ExerciseResponseDtoV1> {
    return {
      ...dto,
      data: {
        ...dto.data,
        exercise: this.exerciseDefinitionMapper.mapFromGenerated(dto.data.exercise),
        languageCode: this.languageCodeMapper.mapFromGenerated(dto.data.languageCode),
        type: this.exerciseTypeMapper.mapFromGenerated(dto.data.type),
        customProperties: <Record<string, unknown> | undefined>dto.data.customProperties,
      },
    };
  }

  public createExerciseV1(
    createExerciseDto: CreateExerciseDtoV1,
    options?: AxiosRequestConfig<unknown> | undefined,
  ): Promise<AxiosResponse<ExerciseResponseDtoV1>> {
    return this.api
      .createExercise(
        {
          ...createExerciseDto,
          languageCode: this.languageCodeMapper.mapToGenerated(createExerciseDto.languageCode),
        },
        options,
      )
      .then((response) => this.mapGeneratedExerciseResponse(response));
  }

  public deleteExerciseV1(id: string, options?: AxiosRequestConfig<unknown> | undefined): Promise<AxiosResponse<void>> {
    return this.api.deleteExercise(id, options);
  }

  public getExerciseV1(
    id: string,
    options?: AxiosRequestConfig<unknown> | undefined,
  ): Promise<AxiosResponse<ExerciseResponseDtoV1>> {
    return this.api.getExercise(id, options).then((response) => this.mapGeneratedExerciseResponse(response));
  }

  public getExerciseListV1(
    custom?: string,
    exerciseType?: ExerciseType,
    languageCode?: LanguageCode,
    options?: AxiosRequestConfig<unknown> | undefined,
  ): Promise<AxiosResponse<Array<ExerciseDescriptorDtoV1>>> {
    return this.api.getExerciseList(custom, exerciseType, languageCode, options).then((r) => ({
      ...r,
      data: r.data.map((dto) => ({
        ...dto,
        languageCode: this.languageCodeMapper.mapFromGenerated(dto.languageCode),
        type: this.exerciseTypeMapper.mapFromGenerated(dto.type),
      })),
    }));
  }

  public replaceExerciseV1(
    id: string,
    replaceExerciseDto: ReplaceExerciseDtoV1,
    options?: AxiosRequestConfig<unknown> | undefined,
  ): Promise<AxiosResponse<ExerciseResponseDtoV1>> {
    return this.api
      .replaceExercise(id, replaceExerciseDto, options)
      .then((response) => this.mapGeneratedExerciseResponse(response));
  }
}