Node.js Examples

// basic-example.js
const MagnetiteClient = require('./magnetite-client');

async function basicExample() {
  const client = new MagnetiteClient(process.env.MAGNETITE_API_KEY);
  
  try {
    const result = await client.generateLeadMagnet({
      projectId: process.env.MAGNETITE_PROJECT_ID,
      email: 'john.smith@example.com',
      fullName: 'John Smith',
      company: 'Acme Corp',
      domain: 'acmecorp.com',
      title: 'VP of Sales',
      industry: 'SaaS'
    });
    
    console.log('Generation started:');
    console.log('Lead ID:', result.leadId);
    console.log('Job ID:', result.jobId);
    console.log('Lead Magnet URL:', result.leadMagnetUrl);
    
    return result;
  } catch (error) {
    console.error('Error generating lead magnet:', error.message);
    throw error;
  }
}

basicExample()
  .then(() => console.log('Done!'))
  .catch(console.error);

// wait-for-completion.js
const MagnetiteClient = require('./magnetite-client');

async function generateAndWait() {
  const client = new MagnetiteClient(process.env.MAGNETITE_API_KEY);
  
  try {
    const generation = await client.generateLeadMagnet({
      projectId: process.env.MAGNETITE_PROJECT_ID,
      email: 'jane.doe@techcorp.com',
      fullName: 'Jane Doe',
      company: 'TechCorp Inc',
      domain: 'techcorp.com',
      title: 'Marketing Director',
      industry: 'Technology',
      companySize: '51-200'
    });
    
    console.log('Generation started with job ID:', generation.jobId);
    console.log('Lead magnet will be available at:', generation.leadMagnetUrl);
    
    const result = await pollUntilComplete(client, generation.jobId);
    
    console.log('Generation completed!');
    console.log('Final URL:', result.leadMagnetUrl);
    console.log('Processing time:', result.processingTime + 's');
    
    return result;
  } catch (error) {
    console.error('Error:', error.message);
    throw error;
  }
}

async function pollUntilComplete(client, jobId, maxAttempts = 30) {
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      const status = await client.checkStatus(jobId);
      
      console.log(`Attempt ${attempt}: ${status.status} (${status.progress}%)`);
      
      if (status.status === 'completed') {
        return status.result;
      }
      
      if (status.status === 'failed') {
        throw new Error('Generation failed: ' + (status.error?.message || 'Unknown error'));
      }
      
      const delay = Math.min(2000 + (attempt * 1000), 10000);
      console.log('Waiting ' + (delay / 1000) + 's before next check...');
      await sleep(delay);
      
    } catch (error) {
      console.error('Polling error on attempt ' + attempt + ':', error.message);
      if (attempt === maxAttempts) throw error;
      await sleep(5000);
    }
  }
  
  throw new Error('Generation did not complete within expected time');
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

generateAndWait()
  .then(() => console.log('All done!'))
  .catch(console.error);

// bulk-processing.js
const MagnetiteClient = require('./magnetite-client');

async function bulkProcessing() {
  const client = new MagnetiteClient(process.env.MAGNETITE_API_KEY);
  
  const leads = [
    {
      email: 'ceo@startup.com',
      fullName: 'Sarah Johnson',
      company: 'StartupCo',
      domain: 'startup.com',
      title: 'CEO'
    },
    {
      email: 'director@bigcorp.com',
      fullName: 'Michael Chen',
      company: 'BigCorp Industries', 
      domain: 'bigcorp.com',
      title: 'Sales Director'
    }
  ];
  
  const results = [];
  const concurrencyLimit = 3;
  
  console.log('Processing', leads.length, 'leads with concurrency limit of', concurrencyLimit);
  
  for (let i = 0; i < leads.length; i += concurrencyLimit) {
    const batch = leads.slice(i, i + concurrencyLimit);
    
    console.log('Processing batch', Math.floor(i / concurrencyLimit) + 1, '(' + batch.length + ' leads)');
    
    const batchPromises = batch.map(async (lead) => {
      try {
        const result = await client.generateLeadMagnet({
          projectId: process.env.MAGNETITE_PROJECT_ID,
          ...lead
        });
        
        console.log('Started generation for', lead.email, '(Job:', result.jobId + ')');
        
        return { lead, success: true, result };
      } catch (error) {
        console.error('Failed to start generation for', lead.email + ':', error.message);
        return { lead, success: false, error: error.message };
      }
    });
    
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    if (i + concurrencyLimit < leads.length) {
      console.log('Waiting 10s before next batch...');
      await sleep(10000);
    }
  }
  
  const successful = results.filter(r => r.success);
  const failed = results.filter(r => !r.success);
  
  console.log('=== SUMMARY ===');
  console.log('Total processed:', results.length);
  console.log('Successful:', successful.length);
  console.log('Failed:', failed.length);
  
  return results;
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

bulkProcessing()
  .then(() => console.log('Bulk processing complete!'))
  .catch(console.error);