whio-api-sdk 1.0.193-bet-staging → 1.0.195-beta-staging

package/src/sdk/modules/audio.module.ts

@@ -0,0 +1,131 @@
+import { BaseClient } from './base-client';
+import {
+  AudioFile,
+  AudioFileStatus,
+  UpdateAudioFileDto,
+  Base64AudioFile,
+  CreateBase64AudioFileDto,
+  UpdateBase64AudioFileDto,
+  AddBase64ChunkResponse,
+} from '../types';
+import urls from '../urls';
+
+export class AudioModule extends BaseClient {
+  // ======================
+  // AUDIO FILE METHODS
+  // ======================
+
+  public async uploadAudioFileToSession(sessionId: string, file: File | Blob, fileName?: string, culturalTranscription?: string): Promise<AudioFile> {
+    const formData = new FormData();
+    formData.append('file', file, fileName);
+
+    if (culturalTranscription) {
+      formData.append('cultural_transcription', culturalTranscription);
+    }
+
+    return this.fileUploadRequest<AudioFile>(`${urls.audioFiles}/upload/${sessionId}`, formData);
+  }
+
+  public async uploadAudioFileWithTranscriptionQueue(sessionId: string, file: File | Blob, options?: { fileName?: string; culturalTranscription?: string }): Promise<AudioFile> {
+    const formData = new FormData();
+    formData.append('file', file, options?.fileName);
+
+    if (options?.culturalTranscription) {
+      formData.append('cultural_transcription', options.culturalTranscription);
+    }
+
+    return this.fileUploadRequest<AudioFile>(`${urls.audioFiles}/upload/${sessionId}`, formData);
+  }
+
+  public async getMyAudioFiles(): Promise<AudioFile[]> {
+    return this.request<AudioFile[]>(`${urls.audioFiles}/my-files`, 'GET');
+  }
+
+  public async getAllAudioFiles(): Promise<AudioFile[]> {
+    return this.request<AudioFile[]>(`${urls.audioFiles}/all`, 'GET');
+  }
+
+  public async getOrganizationAudioFiles(): Promise<AudioFile[]> {
+    return this.request<AudioFile[]>(`${urls.audioFiles}/organization`, 'GET');
+  }
+
+  public async getAudioFilesBySession(sessionId: string): Promise<AudioFile[]> {
+    return this.request<AudioFile[]>(`${urls.audioFiles}/session/${sessionId}`, 'GET');
+  }
+
+  public async getAudioFile(id: string): Promise<AudioFile> {
+    return this.request<AudioFile>(`${urls.audioFiles}/${id}`, 'GET');
+  }
+
+  public async updateAudioFile(id: string, updates: UpdateAudioFileDto): Promise<AudioFile> {
+    return this.request<AudioFile>(`${urls.audioFiles}/${id}`, 'PATCH', updates);
+  }
+
+  public async deleteAudioFile(id: string): Promise<void> {
+    await this.request(`${urls.audioFiles}/${id}`, 'DELETE');
+  }
+
+  public async downloadAudioFile(id: string): Promise<Blob> {
+    return this.downloadRequest(`${urls.audioFiles}/${id}/download`);
+  }
+
+  public async downloadAudioFileAsUrl(id: string): Promise<string> {
+    const blob = await this.downloadAudioFile(id);
+    return URL.createObjectURL(blob);
+  }
+
+  // ======================
+  // TRANSCRIPTION QUEUE HELPER METHODS
+  // ======================
+
+  public async getTranscribedAudioFiles(): Promise<AudioFile[]> {
+    const audioFiles = await this.getMyAudioFiles();
+    return audioFiles.filter(file => file.status === AudioFileStatus.TRANSCRIBED && file.transcription);
+  }
+
+  public async getProcessingAudioFiles(): Promise<AudioFile[]> {
+    const audioFiles = await this.getMyAudioFiles();
+    return audioFiles.filter(file => file.status === AudioFileStatus.PROCESSING);
+  }
+
+  public async getFailedAudioFiles(): Promise<AudioFile[]> {
+    const audioFiles = await this.getMyAudioFiles();
+    return audioFiles.filter(file => file.status === AudioFileStatus.FAILED);
+  }
+
+  // ======================
+  // BASE64 AUDIO FILE METHODS
+  // ======================
+
+  public async createBase64AudioFile(dto: CreateBase64AudioFileDto): Promise<Base64AudioFile> {
+    return this.request<Base64AudioFile>(`${urls.audioFiles}/base64`, 'POST', dto);
+  }
+
+  public async getAllBase64AudioFiles(): Promise<Base64AudioFile[]> {
+    return this.request<Base64AudioFile[]>(`${urls.audioFiles}/base64/all`, 'GET');
+  }
+
+  public async getBase64AudioFilesBySession(sessionId: string): Promise<Base64AudioFile[]> {
+    return this.request<Base64AudioFile[]>(`${urls.audioFiles}/base64/session/${sessionId}`, 'GET');
+  }
+
+  public async getBase64AudioFile(id: string): Promise<Base64AudioFile> {
+    return this.request<Base64AudioFile>(`${urls.audioFiles}/base64/${id}`, 'GET');
+  }
+
+  public async updateBase64AudioFile(id: string, updates: UpdateBase64AudioFileDto): Promise<Base64AudioFile> {
+    return this.request<Base64AudioFile>(`${urls.audioFiles}/base64/${id}`, 'PATCH', updates);
+  }
+
+  public async deleteBase64AudioFile(id: string): Promise<void> {
+    await this.request(`${urls.audioFiles}/base64/${id}`, 'DELETE');
+  }
+
+  public async addBase64Chunk(sessionId: string, base64Chunks: string[]): Promise<AddBase64ChunkResponse> {
+    return this.request<AddBase64ChunkResponse>(`${urls.audioFiles}/base64/add-chunk/${sessionId}`, 'POST', { base64Chunks });
+  }
+
+  public async queueSessionBase64AudioForTranscription(sessionId: string): Promise<{ success: boolean }> {
+    return this.request<{ success: boolean }>(`${urls.audioFiles}/session/${sessionId}/transcribe`, 'POST');
+  }
+}

package/src/sdk/modules/auth.module.ts

@@ -0,0 +1,53 @@
+import { BaseClient } from './base-client';
+import { LoginCredentials, LoginResponse, PasswordChangeResponse, ChangePasswordDto, AdminChangePasswordDto, User } from '../types';
+import urls from '../urls';
+
+export class AuthModule extends BaseClient {
+  public async login(credentials: LoginCredentials): Promise<LoginResponse> {
+    try {
+      const response = await this.request<LoginResponse>(
+        '/auth/login',
+        'POST',
+        credentials,
+        {},
+        true
+      );
+      this.accessToken = response.access_token;
+      this.refreshToken = response.refresh_token;
+      this.user = response.user;
+
+      await this.storage!.setItem('access_token', JSON.stringify(response.access_token));
+      await this.storage!.setItem('refresh_token', JSON.stringify(response.refresh_token));
+      await this.storage!.setItem('user', JSON.stringify(response.user));
+
+      return response;
+    } catch (error) {
+      await this.clearAuth();
+      throw error;
+    }
+  }
+
+  public async logout(): Promise<void> {
+    await this.clearAuth();
+  }
+
+  public async getProfile(): Promise<User> {
+    return this.request<User>(urls.profile, 'GET');
+  }
+
+  public async changePassword(currentPassword: string, newPassword: string): Promise<PasswordChangeResponse> {
+    const dto: ChangePasswordDto = {
+      currentPassword,
+      newPassword,
+    };
+    return this.request<PasswordChangeResponse>(urls.changePassword, 'PATCH', dto);
+  }
+
+  public async adminChangePassword(userId: string, newPassword: string): Promise<PasswordChangeResponse> {
+    const dto: AdminChangePasswordDto = {
+      userId,
+      newPassword,
+    };
+    return this.request<PasswordChangeResponse>(urls.adminChangePassword, 'PATCH', dto);
+  }
+}

package/src/sdk/modules/base-client.ts

@@ -0,0 +1,214 @@
+import { jwtDecode } from 'jwt-decode';
+import { SDKConfig, User, LoginResponse } from '../types';
+
+/**
+ * Base HTTP client for making authenticated requests
+ */
+export class BaseClient {
+  protected baseUrl: string;
+  protected storage: SDKConfig['storage'];
+  protected accessToken: string | null = null;
+  protected refreshToken: string | null = null;
+  protected user: User | null = null;
+
+  constructor(config: SDKConfig = {}) {
+    this.baseUrl = config.baseUrl || '/api';
+    this.storage = config.storage;
+    this.initialize();
+  }
+
+  protected async initialize() {
+    const accessToken = await this.storage!.getItem('access_token');
+    const refreshToken = await this.storage!.getItem('refresh_token');
+    const userString = await this.storage!.getItem('user');
+    this.user = userString ? JSON.parse(userString) : null;
+    this.accessToken = accessToken ? JSON.parse(accessToken) : null;
+    this.refreshToken = refreshToken ? JSON.parse(refreshToken) : null;
+  }
+
+  public async fetchConfig(url: string): Promise<void> {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch config from ${url}`);
+    }
+    const conf = await response.json();
+    this.baseUrl = conf.baseUrl || this.baseUrl;
+  }
+
+  protected async getToken() {
+    const accessToken = await this.storage!.getItem('access_token');
+    this.accessToken = accessToken ? JSON.parse(accessToken) : null;
+    if (!this.accessToken) {
+      throw new Error('Access token not found');
+    }
+
+    if (this.isTokenExpired(this.accessToken)) {
+      if (this.refreshToken) {
+        await this.refreshAccessToken();
+      } else {
+        throw new Error('Access token expired and no refresh token available');
+      }
+    }
+  }
+
+  protected async request<T>(
+    endpoint: string,
+    method: string = 'GET',
+    body?: any,
+    headers: Record<string, string> = {},
+    noToken: boolean = false,
+  ): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`;
+    const defaultHeaders: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'ngrok-skip-browser-warning': 'true'
+    };
+
+    if (noToken) {
+      defaultHeaders['Authorization'] = '';
+    } else {
+      await this.getToken();
+    }
+
+    if (this.accessToken) {
+      defaultHeaders['Authorization'] = `Bearer ${this.accessToken}`;
+    }
+
+    const response = await fetch(url, {
+      method,
+      headers: { ...defaultHeaders, ...headers },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(
+        errorData.message || `Request failed with status ${response.status}`
+      );
+    }
+
+    return response.json();
+  }
+
+  protected async fileUploadRequest<T>(
+    endpoint: string,
+    body?: FormData,
+    headers: Record<string, string> = {}
+  ): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`;
+    const defaultHeaders: Record<string, string> = {
+      'ngrok-skip-browser-warning': 'true'
+    };
+
+    if (this.accessToken) {
+      defaultHeaders['Authorization'] = `Bearer ${this.accessToken}`;
+    }
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { ...defaultHeaders, ...headers },
+      body,
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(
+        errorData.message || `Request failed with status ${response.status}`
+      );
+    }
+
+    return response.json();
+  }
+
+  protected async downloadRequest(endpoint: string): Promise<Blob> {
+    const url = `${this.baseUrl}${endpoint}`;
+
+    await this.getToken();
+
+    const defaultHeaders: Record<string, string> = {
+      'ngrok-skip-browser-warning': 'true'
+    };
+
+    if (this.accessToken) {
+      defaultHeaders['Authorization'] = `Bearer ${this.accessToken}`;
+    }
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: defaultHeaders,
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(
+        errorData.message || `Download failed with status ${response.status}`
+      );
+    }
+
+    return response.blob();
+  }
+
+  protected async clearAuth(): Promise<void> {
+    this.accessToken = null;
+    this.refreshToken = null;
+    this.user = null;
+    await this.storage!.removeItem('access_token');
+    await this.storage!.removeItem('refresh_token');
+    await this.storage!.removeItem('user');
+  }
+
+  protected isTokenExpired(token: string, bufferMinutes: number = 5): boolean {
+    try {
+      const decoded: any = jwtDecode(token);
+      const currentTime = Date.now() / 1000;
+      const bufferTime = bufferMinutes * 60;
+
+      return decoded.exp <= (currentTime + bufferTime);
+    } catch (error) {
+      return true;
+    }
+  }
+
+  protected async refreshAccessToken(): Promise<void> {
+    if (!this.refreshToken) {
+      throw new Error('No refresh token available');
+    }
+
+    try {
+      const response = await this.request<LoginResponse>(
+        '/auth/refresh',
+        'POST',
+        { refresh_token: this.refreshToken },
+        {},
+        true
+      );
+
+      this.accessToken = response.access_token;
+      this.refreshToken = response.refresh_token;
+      this.user = response.user;
+
+      await this.storage!.setItem('access_token', JSON.stringify(response.access_token));
+      await this.storage!.setItem('refresh_token', JSON.stringify(response.refresh_token));
+      await this.storage!.setItem('user', JSON.stringify(response.user));
+    } catch (error) {
+      await this.clearAuth();
+      throw new Error('Failed to refresh access token');
+    }
+  }
+
+  public isAuthenticated(): boolean {
+    return !!this.accessToken;
+  }
+
+  public getCurrentUser(): User | null {
+    return this.user;
+  }
+
+  public getAccessToken(): string | null {
+    return this.accessToken;
+  }
+
+  public getRefreshToken(): string | null {
+    return this.refreshToken;
+  }
+}

package/src/sdk/modules/debug.module.ts

@@ -0,0 +1,44 @@
+import { BaseClient } from './base-client';
+import { DebugSessionSummary } from '../types';
+import urls from '../urls';
+
+export class DebugModule extends BaseClient {
+  /**
+   * Get sessions that do not have medical transcriptions and primary transcription summaries
+   */
+  public async getSessionsWithoutMedicalTranscriptions(): Promise<DebugSessionSummary[]> {
+    return this.request<DebugSessionSummary[]>(`${urls.debug}/sessions/missing-medical-transcriptions`, 'GET');
+  }
+
+  /**
+   * Download a session as a ZIP file containing all related data (decrypted)
+   */
+  public async downloadSessionAsZip(sessionId: string): Promise<Blob> {
+    return this.downloadRequest(`${urls.debug}/sessions/${sessionId}/download`);
+  }
+
+  /**
+   * Download a session as a ZIP file and create a download URL
+   */
+  public async downloadSessionAsZipUrl(sessionId: string): Promise<string> {
+    const blob = await this.downloadSessionAsZip(sessionId);
+    return URL.createObjectURL(blob);
+  }
+
+  /**
+   * Download a session as a ZIP file and trigger browser download
+   */
+  public async downloadSessionAndTriggerDownload(sessionId: string, filename?: string): Promise<void> {
+    const blob = await this.downloadSessionAsZip(sessionId);
+    const url = URL.createObjectURL(blob);
+
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = filename || `session_${sessionId}_${new Date().toISOString().split('T')[0]}.zip`;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+
+    URL.revokeObjectURL(url);
+  }
+}

package/src/sdk/modules/external-integration.module.ts

@@ -0,0 +1,50 @@
+import { BaseClient } from './base-client';
+import {
+  ExternalIntegration,
+  CreateExternalIntegrationDto,
+  UpdateExternalIntegrationDto,
+} from '../types';
+import urls from '../urls';
+
+export class ExternalIntegrationModule extends BaseClient {
+  public async createExternalIntegration(
+    data: CreateExternalIntegrationDto,
+  ): Promise<ExternalIntegration> {
+    return this.request<ExternalIntegration>(
+      urls.externalIntegrations,
+      'POST',
+      data,
+    );
+  }
+
+  public async getExternalIntegrations(): Promise<ExternalIntegration[]> {
+    return this.request<ExternalIntegration[]>(
+      urls.externalIntegrations,
+      'GET',
+    );
+  }
+
+  public async getExternalIntegration(
+    id: string,
+  ): Promise<ExternalIntegration> {
+    return this.request<ExternalIntegration>(
+      `${urls.externalIntegrations}/${id}`,
+      'GET',
+    );
+  }
+
+  public async updateExternalIntegration(
+    id: string,
+    data: UpdateExternalIntegrationDto,
+  ): Promise<ExternalIntegration> {
+    return this.request<ExternalIntegration>(
+      `${urls.externalIntegrations}/${id}`,
+      'PATCH',
+      data,
+    );
+  }
+
+  public async deleteExternalIntegration(id: string): Promise<void> {
+    await this.request(`${urls.externalIntegrations}/${id}`, 'DELETE');
+  }
+}