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

SDK for the Novolanguage Speech Analysis API

import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
import { LanguageCode } from '../../entities';
import { LanguageCodeMapper } from '../../mappers/language-code.mapper';
import { PermissionTypeMapper } from '../../mappers/permission-type.mapper';
import { CreatePublisherDto, PublisherResponseDto, PublisherSettingsResponseDto, UpdatePublisherDto } from './dto';
import {
  Configuration,
  PublisherResponseDto as GeneratedPublisherResponseDto,
  PublishersApi as GeneratedPublishersApi,
  OAuthSettingsDto,
  PublisherDescriptorDto,
  RequestAccountDto,
} from './generated';

export class PublisherApi {
  private readonly publishersApi;
  private readonly permissionTypeMapper: PermissionTypeMapper;
  private readonly languageCodeMapper: LanguageCodeMapper;

  constructor(configuration?: Configuration | undefined, basePath?: string, axios?: AxiosInstance) {
    this.publishersApi = new GeneratedPublishersApi(configuration, basePath, axios);
    this.permissionTypeMapper = new PermissionTypeMapper();
    this.languageCodeMapper = new LanguageCodeMapper();
  }

  private mapGeneratedPublisherResponseDto(
    dto: AxiosResponse<GeneratedPublisherResponseDto>,
  ): AxiosResponse<PublisherResponseDto> {
    const settings: PublisherSettingsResponseDto | undefined = dto.data.settings
      ? {
          ...dto.data.settings,
          allowedPermissions: dto.data.settings.allowedPermissions.map((p) =>
            this.permissionTypeMapper.mapFromGenerated(p),
          ),
          allowedLanguages: dto.data.settings.allowedLanguages.map((l) => this.languageCodeMapper.mapFromGenerated(l)),
          expirationDate: dto.data.settings.expirationDate ? new Date(dto.data.settings.expirationDate) : undefined,
        }
      : undefined;
    return {
      ...dto,
      data: {
        ...dto.data,
        settings,
      },
    };
  }

  public addPublisher(
    createPublisherDto: CreatePublisherDto,
    options?: AxiosRequestConfig,
  ): Promise<AxiosResponse<CreatePublisherDto>> {
    return this.publishersApi
      .addPublisher(
        {
          ...createPublisherDto,
          settings: {
            ...createPublisherDto.settings,
            logSettings: {
              confirmAudioReceived: createPublisherDto.settings.logSettings?.confirmAudioReceived ?? false,
            },
            languageSettings: createPublisherDto.settings.languageSettings,
            allowedPermissions: createPublisherDto.settings.allowedPermissions.map((p) =>
              this.permissionTypeMapper.mapToGenerated(p),
            ),
            allowedLanguages: createPublisherDto.settings.allowedLanguages.map((l) =>
              this.languageCodeMapper.mapToGenerated(l),
            ),
            expirationDate: createPublisherDto.settings.expirationDate
              ? createPublisherDto.settings.expirationDate.toISOString()
              : undefined,
          },
        },
        options,
      )
      .then((r) => ({
        ...r,
        data: {
          ...r.data,
          settings: {
            ...r.data.settings,
            allowedPermissions: r.data.settings.allowedPermissions.map((p) =>
              this.permissionTypeMapper.mapFromGenerated(p),
            ),
            languageSettings: r.data.settings.languageSettings ?? {},
            allowedLanguages: r.data.settings.allowedLanguages.map((l) => this.languageCodeMapper.mapFromGenerated(l)),
            expirationDate: r.data.settings.expirationDate ? new Date(r.data.settings.expirationDate) : undefined,
          },
        },
      }));
  }

  public deletePublisher(id: string, options?: AxiosRequestConfig): Promise<AxiosResponse<void>> {
    return this.publishersApi.deletePublisher(id, options);
  }

  public findAllPublishers(options?: AxiosRequestConfig): Promise<AxiosResponse<PublisherDescriptorDto[]>> {
    return this.publishersApi.findAllPublishers(options);
  }

  public getAndValidatePublisher(
    id: string,
    apiKey?: string,
    anonymous?: boolean,
    options?: AxiosRequestConfig,
  ): Promise<AxiosResponse<PublisherResponseDto>> {
    return this.publishersApi
      .getAndValidatePublisher(id, apiKey, anonymous, options)
      .then((response) => this.mapGeneratedPublisherResponseDto(response));
  }

  public updatePublisher(
    id: string,
    updatePublisherDto: UpdatePublisherDto,
    apiKey?: string,
    options?: AxiosRequestConfig,
  ): Promise<AxiosResponse<PublisherResponseDto>> {
    return this.publishersApi
      .updatePublisher(id, updatePublisherDto, apiKey, options)
      .then((response) => this.mapGeneratedPublisherResponseDto(response));
  }

  public getOAuthSettings(id: string, options?: AxiosRequestConfig): Promise<AxiosResponse<OAuthSettingsDto>> {
    return this.publishersApi.getPublisherOAuthSettings(id, options);
  }

  public async requestTrialAccount(
    contactName: string,
    email: string,
    accountName: string,
    languages: LanguageCode[],
    otherInfo?: { [key: string]: unknown },
    options?: AxiosRequestConfig,
  ): Promise<void> {
    const requestDto: RequestAccountDto = {
      contactName,
      email,
      accountName,
      languages,
      metadata: otherInfo,
    };
    await this.publishersApi.requestAccount(requestDto, options);
  }
}