whio-api-sdk 1.0.155 → 1.0.156

package/src/sdk/sdk.ts

@@ -11,12 +11,19 @@ import {
   UpdateTemplateDto,
   GenerateTranscriptionSummaryDto,
   UpdateTranscriptionSummaryDto,
+  CreateTranscriptionSummaryDto,
   AssignOrganizationRoleDto,
   CreateUserTemplateDto,
   UpdateUserTemplateDto,
   CreateUserDto,
   UpdateUserDto,
+  CreateOrganizationDto,
+  UpdateOrganizationDto,
+  CreateTemplateCategoryDto,
+  UpdateTemplateCategoryDto,
+  AssignTeamTemplateDto,
   OrganizationRoleType,
+  RoleType,
   Organization,
   TemplateCategory,
   Template,
@@ -117,7 +124,6 @@ export class ApiSDK {
   ): Promise<T> {
     const url = `${this.baseUrl}${endpoint}`;
     const defaultHeaders: Record<string, string> = {
-      'Content-Type': 'multipart/form-data',
       'ngrok-skip-browser-warning': 'true'
     };
 
@@ -125,6 +131,7 @@ export class ApiSDK {
       defaultHeaders['Authorization'] = `Bearer ${this.accessToken}`;
     }
 
+    // Don't set Content-Type for FormData - let browser set it with boundary
     const response = await fetch(url, {
       method: 'POST',
       headers: { ...defaultHeaders, ...headers },
@@ -151,7 +158,7 @@ export class ApiSDK {
         true
       );
       this.accessToken = response.access_token;
-      this.refreshToken = response.referesh_token;
+      this.refreshToken = response.refresh_token;
       
       this.user = response.user;
 
@@ -277,12 +284,12 @@ export class ApiSDK {
     return this.request(urls.teams, 'POST', teamDto);
   }
 
-  public async updateTeam(id: string, name: string, description: string): Promise<any> {
+  public async updateTeam(id: string, name: string, description: string): Promise<Team> {
     const teamDto: UpdateTeamDto = {
       name,
       description,
     };
-    return this.request(`${urls.teams}/${id}`, 'PUT', teamDto);
+    return this.request<Team>(`${urls.teams}/${id}`, 'PATCH', teamDto);
   }
 
   public async addUserToTeam(teamId: string, userId: string, roleName: string): Promise<any> {
@@ -294,25 +301,31 @@ export class ApiSDK {
     return this.request(urls.teamRoles, 'POST', assignRoleDto);
   }
 
-  public async removeUserFromTeam(teamId: string, userId: string): Promise<any> {
-    const url = `${urls.teamRoles}/user/${userId}/team/${teamId}`;
-    return this.request(urls.teamRoles, 'DELETE');
+  public async removeUserFromTeam(teamId: string, userId: string): Promise<void> {
+    await this.request(`${urls.teamRoles}/user/${userId}/team/${teamId}`, 'DELETE');
   }
-  //unsure how we are going to deal with template categories just yet
-  public async createTemplate(title: string, content: string): Promise<any> {
-    const templateCategories = await this.request<TemplateCategory[]>(
-      urls.templateCatedories,
-      'GET'
-    );
+  public async createTemplate(title: string, content: string, categoryId?: string): Promise<Template> {
+    let finalCategoryId = categoryId;
+    if (!finalCategoryId) {
+      const templateCategories = await this.request<TemplateCategory[]>(
+        urls.templateCategories,
+        'GET'
+      );
+      finalCategoryId = templateCategories[0]?.id;
+      if (!finalCategoryId) {
+        throw new Error('No template categories available. Please create one first.');
+      }
+    }
+    
     const createTemplateDto: CreateTemplateDto = {
       title,
       content,
       isGlobal: false,
-      categoryId: templateCategories[0]!.id,
+      categoryId: finalCategoryId,
       createdById: this.user!.id,
       organizationId: this.user!.organizationId,
     };
-    return this.request(urls.templates, 'POST', createTemplateDto);
+    return this.request<Template>(urls.templates, 'POST', createTemplateDto);
   }
 
   public async createUserTemplate(
@@ -363,6 +376,10 @@ export class ApiSDK {
     return this.request<UserTemplate[]>(url, 'GET');
   }
 
+  // ======================
+  // trANSCRIPTION SUMMARY METHODS
+  // ====================== 
+
   public async generateTranscriptionSummary(
     transcript: string, templateId: string): Promise<TranscriptionSummary> {
     const generateSummaryDto: GenerateTranscriptionSummaryDto = {
@@ -379,6 +396,14 @@ export class ApiSDK {
     return transcriptionSummary;
   }
 
+  public async getByOrganizationTranscriptionSummaries(
+    organizationId: string): Promise<TranscriptionSummary[]> {
+    return this.request<TranscriptionSummary[]>(
+      `${urls.transcriptionSummaries}/organization/${organizationId}`,
+      'GET'
+    );
+  }
+
   public async generateTranscriptionSummaryFromUserTemplate(
     transcript: string, userTemplateId: string): Promise<TranscriptionSummary> {
     const generateSummaryDto: GenerateTranscriptionSummaryDto = {
@@ -426,7 +451,7 @@ export class ApiSDK {
     return data;
   }
 
-  public async transcribeBase64Audio(base64String: String): Promise<String> {
+  public async transcribeBase64Audio(base64String: string): Promise<string> {
     const transcript = await this.request<any>(
       urls.transcribeBase64Audio,
       'POST',
@@ -434,4 +459,177 @@ export class ApiSDK {
     return transcript.transcript;
   }
 
+  // ======================
+  // AUTH METHODS
+  // ======================
+
+  public async getProfile(): Promise<User> {
+    return this.request<User>(urls.profile, 'GET');
+  }
+
+  // ======================
+  // ORGANIZATION METHODS
+  // ======================
+
+  public async createOrganization(name: string, description?: string): Promise<Organization> {
+    const dto: CreateOrganizationDto = { name, description };
+    return this.request<Organization>(urls.organizations, 'POST', dto);
+  }
+
+  public async getOrganizations(): Promise<Organization[]> {
+    return this.request<Organization[]>(urls.organizations, 'GET');
+  }
+
+  public async getOrganization(id: string): Promise<Organization> {
+    return this.request<Organization>(`${urls.organizations}/${id}`, 'GET');
+  }
+
+  public async updateOrganization(id: string, name?: string, description?: string): Promise<Organization> {
+    const dto: UpdateOrganizationDto = { name, description };
+    return this.request<Organization>(`${urls.organizations}/${id}`, 'PATCH', dto);
+  }
+
+  public async deleteOrganization(id: string): Promise<void> {
+    await this.request(`${urls.organizations}/${id}`, 'DELETE');
+  }
+
+  public async addUserToOrganization(organizationId: string, userId: string): Promise<void> {
+    await this.request(`${urls.organizations}/${organizationId}/users/${userId}`, 'POST');
+  }
+
+  public async removeUserFromOrganization(organizationId: string, userId: string): Promise<void> {
+    await this.request(`${urls.organizations}/${organizationId}/users/${userId}`, 'DELETE');
+  }
+
+  // ======================
+  // USER METHODS
+  // ======================
+
+  public async getUsers(): Promise<User[]> {
+    return this.request<User[]>(urls.users, 'GET');
+  }
+
+  public async getUser(id: string): Promise<User> {
+    return this.request<User>(`${urls.users}/${id}`, 'GET');
+  }
+
+  public async getUsersByOrganization(organizationId: string): Promise<User[]> {
+    return this.request<User[]>(`${urls.users}/organization/${organizationId}`, 'GET');
+  }
+
+  public async updateUser(id: string, data: UpdateUserDto): Promise<User> {
+    return this.request<User>(`${urls.users}/${id}`, 'PATCH', data);
+  }
+
+  public async deleteUser(id: string): Promise<void> {
+    await this.request(`${urls.users}/${id}`, 'DELETE');
+  }
+
+  // ======================
+  // TEAM METHODS
+  // ======================
+
+  public async getTeams(): Promise<Team[]> {
+    return this.request<Team[]>(urls.teams, 'GET');
+  }
+
+  public async getTeam(id: string): Promise<Team> {
+    return this.request<Team>(`${urls.teams}/${id}`, 'GET');
+  }
+
+  public async getTeamsByOrganization(organizationId: string): Promise<Team[]> {
+    return this.request<Team[]>(`${urls.teams}/organization/${organizationId}`, 'GET');
+  }
+
+  public async deleteTeam(id: string): Promise<void> {
+    await this.request(`${urls.teams}/${id}`, 'DELETE');
+  }
+
+  // ======================
+  // TEMPLATE CATEGORY METHODS
+  // ======================
+
+  public async getTemplateCategories(): Promise<TemplateCategory[]> {
+    return this.request<TemplateCategory[]>(urls.templateCategories, 'GET');
+  }
+
+  public async getTemplateCategory(id: string): Promise<TemplateCategory> {
+    return this.request<TemplateCategory>(`${urls.templateCategories}/${id}`, 'GET');
+  }
+
+  public async createTemplateCategory(name: string): Promise<TemplateCategory> {
+    const dto: CreateTemplateCategoryDto = { name };
+    return this.request<TemplateCategory>(urls.templateCategories, 'POST', dto);
+  }
+
+  public async updateTemplateCategory(id: string, name: string): Promise<TemplateCategory> {
+    const dto: UpdateTemplateCategoryDto = { name };
+    return this.request<TemplateCategory>(`${urls.templateCategories}/${id}`, 'PATCH', dto);
+  }
+
+  public async deleteTemplateCategory(id: string): Promise<void> {
+    await this.request(`${urls.templateCategories}/${id}`, 'DELETE');
+  }
+
+  // ======================
+  // ENHANCED TEMPLATE METHODS
+  // ======================
+
+  public async getTemplate(id: string): Promise<Template> {
+    return this.request<Template>(`${urls.templates}/${id}`, 'GET');
+  }
+
+  public async deleteTemplate(id: string): Promise<void> {
+    await this.request(`${urls.templates}/${id}`, 'DELETE');
+  }
+
+  public async getUserTemplate(id: string): Promise<UserTemplate> {
+    return this.request<UserTemplate>(`${urls.userTemplates}/${id}`, 'GET');
+  }
+
+  public async deleteUserTemplate(id: string): Promise<void> {
+    await this.request(`${urls.userTemplates}/${id}`, 'DELETE');
+  }
+
+  // ======================
+  // TEAM TEMPLATE METHODS
+  // ======================
+
+  public async assignTemplateToTeam(teamId: string, templateId: string): Promise<void> {
+    const dto: AssignTeamTemplateDto = { teamId, templateId };
+    await this.request(urls.teamTemplates, 'POST', dto);
+  }
+
+  public async removeTemplateFromTeam(teamId: string, templateId: string): Promise<void> {
+    await this.request(`${urls.teamTemplates}/team/${teamId}/template/${templateId}`, 'DELETE');
+  }
+
+  // ======================
+  // TRANSCRIPTION SUMMARY METHODS
+  // ======================
+
+  public async getTranscriptionSummaries(): Promise<TranscriptionSummary[]> {
+    return this.request<TranscriptionSummary[]>(urls.transcriptionSummaries, 'GET');
+  }
+
+  public async getTranscriptionSummary(id: string): Promise<TranscriptionSummary> {
+    return this.request<TranscriptionSummary>(`${urls.transcriptionSummaries}/${id}`, 'GET');
+  }
+
+  public async getTranscriptionSummariesByUser(userId: string): Promise<TranscriptionSummary[]> {
+    return this.request<TranscriptionSummary[]>(`${urls.transcriptionSummaries}/user/${userId}`, 'GET');
+  }
+
+  public async deleteTranscriptionSummary(id: string): Promise<void> {
+    await this.request(`${urls.transcriptionSummaries}/${id}`, 'DELETE');
+  }
+
+  // ======================
+  // ENHANCED TEAM ROLE METHODS
+  // ======================
+
+  public async removeUserFromTeamFixed(teamId: string, userId: string): Promise<void> {
+    await this.request(`${urls.teamRoles}/user/${userId}/team/${teamId}`, 'DELETE');
+  }
+
 }

package/src/sdk/types.ts

@@ -62,7 +62,7 @@ export interface User {
 // Login response type
 export interface LoginResponse {
   access_token: string;
-  referesh_token: string;
+  refresh_token: string;
   user: User;
 }
 
@@ -276,12 +276,50 @@ export interface Team {
 }
 
 export interface TranscriptionAudioUploadResponse {
-  success: Boolean,
-  transcription: string,
-  model_version: string,
-  metadata: any[],
-  duration: number,
-  log: string,
+  success: boolean;
+  transcription: string;
+  model_version: string;
+  metadata: any[];
+  duration: number;
+  log: string;
 }
 
+// Additional DTOs for missing functionality
+export interface CreateOrganizationDto {
+  name: string;
+  description?: string;
+}
+
+export interface UpdateOrganizationDto {
+  name?: string;
+  description?: string;
+}
+
+export interface CreateTemplateCategoryDto {
+  name: string;
+}
+
+export interface UpdateTemplateCategoryDto {
+  name?: string;
+}
 
+export interface CreateTranscriptionSummaryDto {
+  userId: string;
+  templateId: string;
+  content: string;
+  anonymisedTranscript?: string;
+  metadata?: Record<string, any>;
+}
+
+export interface AssignTeamTemplateDto {
+  teamId: string;
+  templateId: string;
+}
+
+// Enum for global role types to match API
+export enum RoleType {
+  SUPERUSER = 'SUPERUSER',
+  ADMIN = 'ADMIN',
+  TRIAL = 'TRIAL',
+  PAID = 'PAID',
+}

package/src/sdk/urls.ts

@@ -1,24 +1,40 @@
 const urls = {
+  // Auth
   login: '/auth/login',
+  profile: '/auth/profile',
   register: '/auth/register',
   refreshToken: '/auth/refresh-token',
   logout: '/auth/logout',
+  
+  // Users
   user: '/users',
   users: '/users',
-  roles: '/roles',
-  teams: '/teams',
+  
+  // Organizations
   organizations: '/organizations',
   organizationRoles: '/organization-roles',
-  userRoles: '/user-roles',
+  userOrganizationRoles: '/user-organization-roles',
+  
+  // Teams
+  teams: '/teams',
   teamRoles: '/team-roles',
+  teamTemplates: '/team-templates',
+  
+  // Templates
   templates: '/templates',
-  templateCatedories: '/template-categories',
+  templateCategories: '/template-categories',
   userTemplates: '/user-templates',
-  userOrganizationRoles: '/user-organization-roles',
+  
+  // Transcription Summaries
+  transcriptionSummaries: '/transcription-summaries',
   transcriptionSummary: '/transcription-summaries/generate',
   uploadAudioLarge: '/transcription-summaries/upload-audio-large',
   uploadAudio: '/transcription-summaries/upload-audio',
   transcribeBase64Audio: '/transcription-summaries/transcribe-base64',
+  
+  // Roles
+  roles: '/roles',
+  userRoles: '/user-roles',
 }
 
 export default urls;

package/test-comprehensive.mjs

@@ -0,0 +1,276 @@
+// Comprehensive SDK test against localhost:3000
+import { ApiSDK } from './dist/index.js';
+
+class TestStorage {
+  constructor() {
+    this.storage = new Map();
+  }
+  
+  async getItem(key) {
+    return this.storage.get(key) || null;
+  }
+  
+  async setItem(key, value) {
+    this.storage.set(key, value);
+  }
+  
+  async removeItem(key) {
+    this.storage.delete(key);
+  }
+}
+
+async function runTests() {
+  console.log('🧪 Starting comprehensive SDK tests against localhost:3000\n');
+  
+  const storage = new TestStorage();
+  const sdk = new ApiSDK({
+    baseUrl: 'http://localhost:3000',
+    storage
+  });
+
+  let testResults = {
+    passed: 0,
+    failed: 0,
+    errors: []
+  };
+
+  async function test(name, testFn) {
+    try {
+      console.log(`📋 Testing: ${name}`);
+      await testFn();
+      console.log(`✅ ${name} - PASSED\n`);
+      testResults.passed++;
+    } catch (error) {
+      console.log(`❌ ${name} - FAILED: ${error.message}\n`);
+      testResults.failed++;
+      testResults.errors.push({ test: name, error: error.message });
+    }
+  }
+
+  // Test authentication
+  await test('Login with credentials', async () => {
+    const response = await sdk.login({
+      email: 'test@example.com',
+      password: 'password'
+    });
+    
+    if (!response.access_token) throw new Error('No access token returned');
+    if (!response.user) throw new Error('No user returned');
+    console.log(`   User: ${response.user.firstName} ${response.user.lastName}`);
+  });
+
+  await test('Check authentication status', async () => {
+    const isAuth = sdk.isAuthenticated();
+    if (!isAuth) throw new Error('Should be authenticated after login');
+  });
+
+  await test('Get current user', async () => {
+    const user = sdk.getCurrentUser();
+    if (!user) throw new Error('Current user should be available');
+    console.log(`   Current user: ${user.firstName} ${user.lastName}`);
+  });
+
+  await test('Get profile', async () => {
+    const profile = await sdk.getProfile();
+    if (!profile.id) throw new Error('Profile should have ID');
+    console.log(`   Profile ID: ${profile.id}`);
+  });
+
+  // Test organization methods
+  await test('Get organizations', async () => {
+    const orgs = await sdk.getOrganizations();
+    if (!Array.isArray(orgs)) throw new Error('Should return array of organizations');
+    console.log(`   Found ${orgs.length} organizations`);
+  });
+
+  await test('Get current organization', async () => {
+    const user = sdk.getCurrentUser();
+    const org = await sdk.getOrganization(user.organizationId);
+    if (!org.id) throw new Error('Organization should have ID');
+    console.log(`   Organization: ${org.name}`);
+  });
+
+  // Test user methods
+  await test('Get users', async () => {
+    const users = await sdk.getUsers();
+    if (!Array.isArray(users)) throw new Error('Should return array of users');
+    console.log(`   Found ${users.length} users`);
+  });
+
+  await test('Get users by organization', async () => {
+    const user = sdk.getCurrentUser();
+    const users = await sdk.getUsersByOrganization(user.organizationId);
+    if (!Array.isArray(users)) throw new Error('Should return array of users');
+    console.log(`   Found ${users.length} users in organization`);
+  });
+
+  // Test team methods
+  await test('Get teams', async () => {
+    const teams = await sdk.getTeams();
+    if (!Array.isArray(teams)) throw new Error('Should return array of teams');
+    console.log(`   Found ${teams.length} teams`);
+  });
+
+  await test('Create team', async () => {
+    const team = await sdk.createTeam('Test Team', 'A test team for SDK testing');
+    if (!team.id) throw new Error('Created team should have ID');
+    console.log(`   Created team: ${team.name} (ID: ${team.id})`);
+    
+    // Store team ID for cleanup
+    global.testTeamId = team.id;
+  });
+
+  // Test template category methods
+  await test('Get template categories', async () => {
+    const categories = await sdk.getTemplateCategories();
+    if (!Array.isArray(categories)) throw new Error('Should return array of categories');
+    console.log(`   Found ${categories.length} template categories`);
+  });
+
+  await test('Create template category', async () => {
+    const category = await sdk.createTemplateCategory('Test Category');
+    if (!category.id) throw new Error('Created category should have ID');
+    console.log(`   Created category: ${category.name} (ID: ${category.id})`);
+    
+    global.testCategoryId = category.id;
+  });
+
+  // Test template methods
+  await test('Get templates', async () => {
+    const templates = await sdk.getTemplates();
+    if (!Array.isArray(templates)) throw new Error('Should return array of templates');
+    console.log(`   Found ${templates.length} templates`);
+  });
+
+  await test('Create template', async () => {
+    const template = await sdk.createTemplate(
+      'Test Template', 
+      'This is a test template content',
+      global.testCategoryId
+    );
+    if (!template.id) throw new Error('Created template should have ID');
+    console.log(`   Created template: ${template.title} (ID: ${template.id})`);
+    
+    global.testTemplateId = template.id;
+  });
+
+  await test('Update template', async () => {
+    const updated = await sdk.updateTemplate(
+      'Updated Test Template',
+      'Updated test template content',
+      global.testTemplateId
+    );
+    if (updated.title !== 'Updated Test Template') {
+      throw new Error('Template title should be updated');
+    }
+    console.log(`   Updated template title: ${updated.title}`);
+  });
+
+  // Test user template methods
+  await test('Get user templates', async () => {
+    const userTemplates = await sdk.getUserTemplates();
+    if (!Array.isArray(userTemplates)) throw new Error('Should return array of user templates');
+    console.log(`   Found ${userTemplates.length} user templates`);
+  });
+
+  await test('Create user template', async () => {
+    const userTemplate = await sdk.createUserTemplate(
+      'Test User Template',
+      'This is a test user template',
+      global.testTemplateId
+    );
+    if (!userTemplate.id) throw new Error('Created user template should have ID');
+    console.log(`   Created user template: ${userTemplate.title} (ID: ${userTemplate.id})`);
+    
+    global.testUserTemplateId = userTemplate.id;
+  });
+
+  // Test transcription summary methods
+  await test('Get transcription summaries', async () => {
+    const summaries = await sdk.getTranscriptionSummaries();
+    if (!Array.isArray(summaries)) throw new Error('Should return array of summaries');
+    console.log(`   Found ${summaries.length} transcription summaries`);
+  });
+
+  await test('Generate transcription summary', async () => {
+    const summary = await sdk.generateTranscriptionSummary(
+      'This is a test transcript for testing purposes',
+      global.testTemplateId
+    );
+    if (!summary.id) throw new Error('Generated summary should have ID');
+    console.log(`   Generated summary (ID: ${summary.id})`);
+    
+    global.testSummaryId = summary.id;
+  });
+
+  await test('Update transcription summary', async () => {
+    const updated = await sdk.updateTranscriptionSummary(
+      global.testSummaryId,
+      'Updated summary content'
+    );
+    if (updated.content !== 'Updated summary content') {
+      throw new Error('Summary content should be updated');
+    }
+    console.log(`   Updated summary content`);
+  });
+
+  // Test audio upload (mock file)
+  await test('Upload audio file', async () => {
+    const formData = new FormData();
+    const blob = new Blob(['fake audio data'], { type: 'audio/wav' });
+    formData.append('audio', blob, 'test.wav');
+    
+    try {
+      const result = await sdk.uploadAudioFile(formData);
+      console.log(`   Upload result: ${result ? 'Success' : 'No response'}`);
+    } catch (error) {
+      if (error.message.includes('413') || error.message.includes('file')) {
+        console.log(`   Upload failed as expected (file validation): ${error.message}`);
+      } else {
+        throw error;
+      }
+    }
+  });
+
+  // Test base64 audio transcription
+  await test('Transcribe base64 audio', async () => {
+    try {
+      const transcript = await sdk.transcribeBase64Audio('fake-base64-audio-data');
+      console.log(`   Transcript: ${transcript}`);
+    } catch (error) {
+      if (error.message.includes('400') || error.message.includes('base64')) {
+        console.log(`   Transcription failed as expected (invalid base64): ${error.message}`);
+      } else {
+        throw error;
+      }
+    }
+  });
+
+  // Test logout
+  await test('Logout', async () => {
+    await sdk.logout();
+    const isAuth = sdk.isAuthenticated();
+    if (isAuth) throw new Error('Should not be authenticated after logout');
+  });
+
+  // Print test results
+  console.log('\n📊 Test Results:');
+  console.log(`✅ Passed: ${testResults.passed}`);
+  console.log(`❌ Failed: ${testResults.failed}`);
+  console.log(`📈 Success Rate: ${((testResults.passed / (testResults.passed + testResults.failed)) * 100).toFixed(1)}%`);
+
+  if (testResults.errors.length > 0) {
+    console.log('\n💥 Errors:');
+    testResults.errors.forEach(({ test, error }) => {
+      console.log(`   ${test}: ${error}`);
+    });
+  }
+}
+
+// Handle process termination
+process.on('unhandledRejection', (reason, promise) => {
+  console.log('Unhandled Rejection at:', promise, 'reason:', reason);
+});
+
+// Run the tests
+runTests().catch(console.error);