whio-api-sdk 1.0.154 → 1.0.156

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);

package/test-sdk.cjs

@@ -0,0 +1,190 @@
+const { ApiSDK } = require('./dist/index.js');
+
+// Custom storage implementation for Node.js
+class NodeStorage {
+  constructor() {
+    this.items = {};
+  }
+
+  getItem(key) {
+    return this.items[key] || null;
+  }
+
+  setItem(key, value) {
+    this.items[key] = value;
+    console.log(`Stored ${key}`);
+  }
+
+  removeItem(key) {
+    delete this.items[key];
+    console.log(`Removed ${key}`);
+  }
+}
+
+const config = {
+  baseUrl: 'http://localhost:3000',
+  storage: new NodeStorage(),
+};
+
+const sdk = new ApiSDK(config);
+
+async function createTestUser() {
+  console.log('🔧 Creating test user directly via API...');
+  
+  const createUserDto = {
+    email: 'test@example.com',
+    password: 'testpassword123',
+    firstName: 'Test',
+    lastName: 'User',
+  };
+
+  try {
+    const response = await fetch('http://localhost:3000/users', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(createUserDto),
+    });
+
+    if (response.ok) {
+      const user = await response.json();
+      console.log('✅ Test user created:', user);
+      return {
+        email: createUserDto.email,
+        password: createUserDto.password,
+      };
+    } else {
+      const error = await response.json().catch(() => ({}));
+      console.log('⚠️ User might already exist or need different approach:', error);
+      
+      return {
+        email: 'test@example.com',
+        password: 'testpassword123',
+      };
+    }
+  } catch (error) {
+    console.log('⚠️ Error creating user, trying with default credentials:', error);
+    return {
+      email: 'test@example.com', 
+      password: 'testpassword123',
+    };
+  }
+}
+
+async function testSDK() {
+  try {
+    console.log('🚀 Starting SDK Test...\n');
+
+    // Step 1: Create or get test credentials
+    const credentials = await createTestUser();
+    console.log('📋 Using credentials:', { email: credentials.email, password: '***' });
+
+    // Step 2: Test login
+    console.log('\n🔐 Testing login...');
+    const loginResponse = await sdk.login(credentials);
+    console.log('✅ Login successful!');
+    console.log('Access token:', loginResponse.access_token.substring(0, 20) + '...');
+    console.log('User ID:', loginResponse.user.id);
+    console.log('User Email:', loginResponse.user.email);
+
+    // Step 3: Test get profile
+    console.log('\n👤 Testing get profile...');
+    try {
+      const profile = await sdk.getProfile();
+      console.log('✅ Profile retrieved - ID:', profile.id, 'Email:', profile.email);
+    } catch (error) {
+      console.log('⚠️ Profile error:', error.message);
+    }
+
+    // Step 4: Test template categories
+    console.log('\n📂 Testing template categories...');
+    try {
+      const categories = await sdk.getTemplateCategories();
+      console.log('✅ Template categories:', categories.length, 'found');
+      if (categories.length > 0) {
+        console.log('First category:', categories[0]);
+      }
+    } catch (error) {
+      console.log('⚠️ Template categories error:', error.message);
+    }
+
+    // Step 5: Test templates
+    console.log('\n📄 Testing templates...');
+    try {
+      const templates = await sdk.getTemplates();
+      console.log('✅ Templates retrieved:', templates.length, 'templates');
+      if (templates.length > 0) {
+        console.log('First template:', templates[0].title);
+      }
+    } catch (error) {
+      console.log('⚠️ Templates error:', error.message);
+    }
+
+    // Step 6: Test user templates
+    console.log('\n📝 Testing user templates...');
+    try {
+      const userTemplates = await sdk.getUserTemplates();
+      console.log('✅ User templates retrieved:', userTemplates.length, 'templates');
+    } catch (error) {
+      console.log('⚠️ User templates error:', error.message);
+    }
+
+    // Step 7: Test organizations (if user has access)
+    console.log('\n🏢 Testing organizations...');
+    try {
+      const organizations = await sdk.getOrganizations();
+      console.log('✅ Organizations retrieved:', organizations.length, 'found');
+    } catch (error) {
+      console.log('⚠️ Organizations error (might need admin access):', error.message);
+    }
+
+    // Step 8: Test teams (if user has access)
+    console.log('\n👥 Testing teams...');
+    try {
+      const teams = await sdk.getTeams();
+      console.log('✅ Teams retrieved:', teams.length, 'found');
+    } catch (error) {
+      console.log('⚠️ Teams error (might need admin access):', error.message);
+    }
+
+    // Step 9: Test creating a template category (if allowed)
+    console.log('\n🆕 Testing create template category...');
+    try {
+      const newCategory = await sdk.createTemplateCategory('Test Category ' + Date.now());
+      console.log('✅ Template category created:', newCategory);
+    } catch (error) {
+      console.log('⚠️ Create template category error:', error.message);
+    }
+
+    // Step 10: Test creating a user template
+    console.log('\n📝 Testing create user template...');
+    try {
+      const userTemplate = await sdk.createUserTemplate(
+        'Test User Template',
+        'This is a test template content',
+        undefined // no original template
+      );
+      console.log('✅ User template created:', userTemplate.title);
+    } catch (error) {
+      console.log('⚠️ Create user template error:', error.message);
+    }
+
+    // Step 11: Test logout
+    console.log('\n🚪 Testing logout...');
+    await sdk.logout();
+    console.log('✅ Logout successful!');
+    console.log('Is authenticated:', sdk.isAuthenticated());
+
+    console.log('\n🎉 SDK Test completed successfully!');
+
+  } catch (error) {
+    console.error('❌ SDK Test failed:', error);
+    if (error instanceof Error) {
+      console.error('Error message:', error.message);
+    }
+  }
+}
+
+// Run the test
+testSDK().catch(console.error);

package/test-sdk.mjs

@@ -0,0 +1,228 @@
+import { ApiSDK } from './dist/index.js';
+
+// Custom storage implementation for Node.js
+class NodeStorage {
+  constructor() {
+    this.items = {};
+  }
+
+  getItem(key) {
+    return this.items[key] || null;
+  }
+
+  setItem(key, value) {
+    this.items[key] = value;
+    console.log(`✅ Stored ${key}`);
+  }
+
+  removeItem(key) {
+    delete this.items[key];
+    console.log(`🗑️ Removed ${key}`);
+  }
+}
+
+const config = {
+  baseUrl: 'http://localhost:3000',
+  storage: new NodeStorage(),
+};
+
+const sdk = new ApiSDK(config);
+
+async function createTestUser() {
+  console.log('🔧 Creating test user directly via API...');
+  
+  const createUserDto = {
+    email: 'test@example.com',
+    password: 'testpassword123',
+    firstName: 'Test',
+    lastName: 'User',
+  };
+
+  try {
+    const response = await fetch('http://localhost:3000/users', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(createUserDto),
+    });
+
+    if (response.ok) {
+      const user = await response.json();
+      console.log('✅ Test user created:', user.email);
+      return {
+        email: createUserDto.email,
+        password: createUserDto.password,
+      };
+    } else {
+      const error = await response.json().catch(() => ({ message: `Status: ${response.status}` }));
+      console.log('⚠️ User creation response:', error);
+      
+      // Try with existing credentials
+      return {
+        email: 'test@example.com',
+        password: 'testpassword123',
+      };
+    }
+  } catch (error) {
+    console.log('⚠️ Error creating user, trying with default credentials:', error.message);
+    return {
+      email: 'test@example.com', 
+      password: 'testpassword123',
+    };
+  }
+}
+
+async function testSDK() {
+  try {
+    console.log('🚀 Starting SDK Test against localhost:3000...\n');
+
+    // Step 1: Create or get test credentials
+    const credentials = await createTestUser();
+    console.log('📋 Using credentials:', { email: credentials.email, password: '***' });
+
+    // Step 2: Test login
+    console.log('\n🔐 Testing login...');
+    const loginResponse = await sdk.login(credentials);
+    console.log('✅ Login successful!');
+    console.log('📄 Access token:', loginResponse.access_token.substring(0, 20) + '...');
+    console.log('👤 User ID:', loginResponse.user.id);
+    console.log('📧 User Email:', loginResponse.user.email);
+    console.log('🏢 Organization ID:', loginResponse.user.organizationId);
+
+    // Step 3: Test get profile
+    console.log('\n👤 Testing get profile...');
+    try {
+      const profile = await sdk.getProfile();
+      console.log('✅ Profile retrieved - ID:', profile.id, 'Email:', profile.email);
+    } catch (error) {
+      console.log('⚠️ Profile error:', error.message);
+    }
+
+    // Step 4: Test template categories
+    console.log('\n📂 Testing template categories...');
+    try {
+      const categories = await sdk.getTemplateCategories();
+      console.log('✅ Template categories:', categories.length, 'found');
+      if (categories.length > 0) {
+        console.log('📝 First category:', categories[0]);
+      }
+    } catch (error) {
+      console.log('⚠️ Template categories error:', error.message);
+    }
+
+    // Step 5: Test templates
+    console.log('\n📄 Testing templates...');
+    try {
+      const templates = await sdk.getTemplates();
+      console.log('✅ Templates retrieved:', templates.length, 'templates');
+      if (templates.length > 0) {
+        console.log('📋 First template:', templates[0].title);
+      }
+    } catch (error) {
+      console.log('⚠️ Templates error:', error.message);
+    }
+
+    // Step 6: Test user templates
+    console.log('\n📝 Testing user templates...');
+    try {
+      const userTemplates = await sdk.getUserTemplates();
+      console.log('✅ User templates retrieved:', userTemplates.length, 'templates');
+      if (userTemplates.length > 0) {
+        console.log('📄 First user template:', userTemplates[0].title);
+      }
+    } catch (error) {
+      console.log('⚠️ User templates error:', error.message);
+    }
+
+    // Step 7: Test organizations (if user has access)
+    console.log('\n🏢 Testing organizations...');
+    try {
+      const organizations = await sdk.getOrganizations();
+      console.log('✅ Organizations retrieved:', organizations.length, 'found');
+      if (organizations.length > 0) {
+        console.log('🏢 First org:', organizations[0].name);
+      }
+    } catch (error) {
+      console.log('⚠️ Organizations error (might need admin access):', error.message);
+    }
+
+    // Step 8: Test teams (if user has access)
+    console.log('\n👥 Testing teams...');
+    try {
+      const teams = await sdk.getTeams();
+      console.log('✅ Teams retrieved:', teams.length, 'found');
+      if (teams.length > 0) {
+        console.log('👥 First team:', teams[0].name);
+      }
+    } catch (error) {
+      console.log('⚠️ Teams error (might need admin access):', error.message);
+    }
+
+    // Step 9: Test transcription summaries for current user
+    console.log('\n📊 Testing transcription summaries...');
+    try {
+      const profile = sdk.getCurrentUser();
+      if (profile) {
+        const summaries = await sdk.getTranscriptionSummariesByUser(profile.id);
+        console.log('✅ Transcription summaries retrieved:', summaries.length, 'summaries');
+      }
+    } catch (error) {
+      console.log('⚠️ Transcription summaries error:', error.message);
+    }
+
+    // Step 10: Test creating a user template
+    console.log('\n🆕 Testing create user template...');
+    try {
+      const userTemplate = await sdk.createUserTemplate(
+        'SDK Test Template - ' + new Date().toISOString(),
+        'This is a test template created by the SDK test',
+        undefined // no original template
+      );
+      console.log('✅ User template created:', userTemplate.title);
+      
+      // Test updating the template
+      console.log('\n📝 Testing update user template...');
+      const updatedTemplate = await sdk.updateUserTemplate(
+        userTemplate.id,
+        'Updated SDK Test Template - ' + new Date().toISOString(),
+        'This template was updated by the SDK test'
+      );
+      console.log('✅ User template updated:', updatedTemplate.title);
+
+    } catch (error) {
+      console.log('⚠️ Create/update user template error:', error.message);
+    }
+
+    // Step 11: Test base64 audio transcription (if working)
+    console.log('\n🎙️ Testing base64 audio transcription...');
+    try {
+      // This is a very short base64 audio sample - replace with actual audio
+      const mockBase64Audio = 'SGVsbG8gV29ybGQ='; // "Hello World" in base64
+      const transcription = await sdk.transcribeBase64Audio(mockBase64Audio);
+      console.log('✅ Audio transcription result:', transcription);
+    } catch (error) {
+      console.log('⚠️ Audio transcription error (expected with mock data):', error.message);
+    }
+
+    // Step 12: Test logout
+    console.log('\n🚪 Testing logout...');
+    await sdk.logout();
+    console.log('✅ Logout successful!');
+    console.log('🔒 Is authenticated:', sdk.isAuthenticated());
+
+    console.log('\n🎉 SDK Test completed successfully!');
+    console.log('📈 All major SDK functionality has been tested against localhost:3000');
+
+  } catch (error) {
+    console.error('❌ SDK Test failed:', error);
+    if (error instanceof Error) {
+      console.error('💥 Error message:', error.message);
+      console.error('📍 Stack trace:', error.stack);
+    }
+  }
+}
+
+// Run the test
+console.log('🎯 Testing whio-SDK against localhost:3000...');
+testSDK().catch(console.error);