twenty-import-csv 1.0.0

package/src/cli.ts

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+import { loadToTwenty } from './load-real';
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as Papa from 'papaparse';
+import axios from 'axios';
+
+interface Options {
+  file: string;
+  object: string;
+  twentyUrl: string;
+  twentyKey: string;
+  dryRun: boolean;
+  batch?: number;
+}
+
+const program = new Command();
+
+program
+  .name('twenty-import-csv')
+  .description('Universal CSV import tool for Twenty CRM')
+  .version('1.0.0');
+
+program
+  .requiredOption('-f, --file <path>', 'CSV file to import')
+  .requiredOption('-o, --object <type>', 'Twenty object type (people, companies, opportunities, etc.)')
+  .requiredOption('-u, --twenty-url <url>', 'Twenty CRM URL')
+  .requiredOption('-k, --twenty-key <key>', 'Twenty CRM API key')
+  .option('-d, --dry-run', 'Preview import without writing data', false)
+  .option('-b, --batch <number>', 'Batch size for API calls', '60')
+  .parse();
+
+const options = program.opts() as Options;
+
+async function parseCSV(filePath: string): Promise<any[]> {
+  return new Promise((resolve, reject) => {
+    const fileContent = fs.readFileSync(filePath, 'utf8');
+    
+    Papa.parse(fileContent, {
+      header: true,
+      skipEmptyLines: true,
+      complete: (results) => {
+        if (results.errors.length > 0) {
+          console.warn(`⚠️ CSV parsing warnings: ${results.errors.length}`);
+        }
+        resolve(results.data);
+      },
+      error: (error: any) => {
+        reject(new Error(`CSV parsing failed: ${error.message}`));
+      }
+    });
+  });
+}
+
+async function main() {
+  try {
+    console.log('🚀 Twenty CSV Import Tool');
+    console.log(`📁 File: ${options.file}`);
+    console.log(`🎯 Object: ${options.object}`);
+    console.log(`🔗 Twenty URL: ${options.twentyUrl}`);
+    console.log(`🧪 Dry Run: ${options.dryRun ? 'YES' : 'NO'}`);
+    
+    // Check if file exists
+    if (!fs.existsSync(options.file)) {
+      console.error(`❌ Error: File ${options.file} not found`);
+      process.exit(1);
+    }
+
+    // Parse CSV
+    console.log('\n📖 Parsing CSV file...');
+    const data = await parseCSV(options.file);
+    console.log(`✅ Parsed ${data.length} records`);
+
+    // Simple field mapping for people
+    const mappedData = data.map((record: any) => {
+      const mapped: any = {};
+      
+      // Auto-map common fields for people
+      if (options.object === 'people') {
+        mapped['name.firstName'] = record.first_name || record.firstName || '';
+        mapped['name.lastName'] = record.last_name || record.lastName || '';
+        mapped['email'] = record.email || '';
+        mapped['phone'] = record.phone || '';
+        mapped['jobTitle'] = record.job_title || record.jobTitle || '';
+        mapped['city'] = record.city || '';
+        mapped['country'] = record.country || '';
+      } else {
+        // For other objects, just pass through
+        Object.assign(mapped, record);
+      }
+      
+      return mapped;
+    });
+
+    // Show preview for dry run
+    if (options.dryRun) {
+      console.log('\n👀 DRY RUN - Preview (first 5 records):');
+      console.log(JSON.stringify(mappedData.slice(0, 5), null, 2));
+      console.log(`\n📊 Summary: ${mappedData.length} records ready for import`);
+      return;
+    }
+
+    // Load data to Twenty
+    console.log('\n📤 Loading data to Twenty CRM...');
+    const batchSize = parseInt(String(options.batch || '60'));
+    const client = axios.create({
+      baseURL: `${options.twentyUrl.replace(/\/$/, '')}/rest`,
+      headers: {
+        'Authorization': `Bearer ${options.twentyKey}`,
+        'Content-Type': 'application/json'
+      },
+      timeout: 30000
+    });
+
+    let successCount = 0;
+    let errorCount = 0;
+
+    // Process in batches
+    for (let i = 0; i < mappedData.length; i += batchSize) {
+      const batch = mappedData.slice(i, i + batchSize);
+      const batchNumber = Math.floor(i / batchSize) + 1;
+      const totalBatches = Math.ceil(mappedData.length / batchSize);
+
+      console.log(`📤 Batch ${batchNumber}/${totalBatches}: ${batch.length} records`);
+
+      try {
+        const response = await client.post(`/${options.object}`, {
+          data: batch
+        });
+        
+        if (response.status === 200) {
+          successCount += batch.length;
+          console.log(`✅ Batch ${batchNumber} imported successfully`);
+        } else {
+          throw new Error(`HTTP ${response.status}`);
+        }
+      } catch (error: any) {
+        errorCount += batch.length;
+        console.error(`❌ Batch ${batchNumber} failed:`, error.response?.data || error.message);
+      }
+
+      // Small delay to avoid rate limiting
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+
+    console.log('\n✅ Import completed!');
+    console.log(`📊 Success: ${successCount}`);
+    console.log(`❌ Errors: ${errorCount}`);
+    console.log(`📈 Success rate: ${((successCount / (successCount + errorCount)) * 100).toFixed(2)}%`);
+
+  } catch (error) {
+    console.error('❌ Import failed:', (error as Error).message);
+    process.exit(1);
+  }
+}
+
+main();

package/src/load-graphql.ts

@@ -0,0 +1,238 @@
+import axios, { AxiosInstance } from 'axios';
+import { ParsedRecord } from './parser';
+import * as fs from 'fs';
+
+export interface LoadResult {
+  success: number;
+  errors: number;
+  errorLog: string[];
+}
+
+export interface BatchResult {
+  success: boolean;
+  count: number;
+  error?: string;
+}
+
+export class TwentyGraphQLClient {
+  private client: AxiosInstance;
+  private baseUrl: string;
+  private apiKey: string;
+
+  constructor(baseUrl: string, apiKey: string) {
+    this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+    this.apiKey = apiKey;
+    
+    this.client = axios.create({
+      baseURL: `${this.baseUrl}`,
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json'
+      },
+      timeout: 30000
+    });
+  }
+
+  async testConnection(): Promise<boolean> {
+    try {
+      const query = `
+        query {
+          people {
+            edges {
+              node {
+                id
+              }
+            }
+          }
+        }
+      `;
+      
+      const response = await this.client.post('/graphql', { query });
+      return response.status === 200 && !response.data.errors;
+    } catch (error: any) {
+      console.error('❌ Connection test failed:', error.response?.data || error.message);
+      return false;
+    }
+  }
+
+  async createRecords(objectType: string, records: ParsedRecord[]): Promise<BatchResult> {
+    try {
+      // Prepare GraphQL mutation based on object type
+      let mutation: string;
+      let inputType: string;
+      
+      switch (objectType.toLowerCase()) {
+        case 'people':
+          mutation = `
+            mutation CreatePeople($input: [PersonCreateInput!]!) {
+              createPeople(input: $input) {
+                id
+                name {
+                  firstName
+                  lastName
+                }
+                email
+                phone
+              }
+            }
+          `;
+          inputType = 'PersonCreateInput';
+          break;
+          
+        case 'companies':
+          mutation = `
+            mutation CreateCompanies($input: [CompanyCreateInput!]!) {
+              createCompanies(input: $input) {
+                id
+                name
+                domainName
+                phone
+              }
+            }
+          `;
+          inputType = 'CompanyCreateInput';
+          break;
+          
+        default:
+          throw new Error(`Unsupported object type: ${objectType}`);
+      }
+
+      // Transform records to GraphQL format
+      const graphqlRecords = records.map(record => {
+        const transformed: any = {};
+        
+        if (objectType === 'people') {
+          // Handle name field
+          if (record['name.firstName'] || record['name.lastName']) {
+            transformed.name = {
+              firstName: record['name.firstName'] || '',
+              lastName: record['name.lastName'] || ''
+            };
+          }
+          
+          // Copy other fields
+          if (record.email) transformed.email = record.email;
+          if (record.phone) transformed.phone = record.phone;
+          if (record.jobTitle) transformed.jobTitle = record.jobTitle;
+          if (record.city) transformed.city = record.city;
+          if (record.country) transformed.country = record.country;
+        }
+        
+        return transformed;
+      });
+
+      const response = await this.client.post('/graphql', {
+        query: mutation,
+        variables: {
+          input: graphqlRecords
+        }
+      });
+      
+      if (response.data.errors) {
+        return {
+          success: false,
+          count: 0,
+          error: response.data.errors.map((e: any) => e.message).join('; ')
+        };
+      }
+      
+      return {
+        success: true,
+        count: records.length
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        count: 0,
+        error: error.response?.data?.message || error.message
+      };
+    }
+  }
+
+  getObjectEndpoint(objectType: string): string {
+    const endpoints: { [key: string]: string } = {
+      'people': 'people',
+      'persons': 'people',
+      'contacts': 'people',
+      'companies': 'companies',
+      'organization': 'companies',
+      'opportunities': 'opportunities',
+      'deals': 'opportunities',
+      'tasks': 'tasks',
+      'notes': 'notes'
+    };
+    
+    return endpoints[objectType.toLowerCase()] || objectType;
+  }
+}
+
+export async function loadToTwenty(
+  data: ParsedRecord[],
+  objectType: string,
+  twentyUrl: string,
+  twentyKey: string,
+  batchSize: number,
+  progressBar: any
+): Promise<LoadResult> {
+  const client = new TwentyGraphQLClient(twentyUrl, twentyKey);
+  const errorLog: string[] = [];
+  let successCount = 0;
+  let errorCount = 0;
+
+  // Test connection first
+  console.log('🔗 Testing Twenty CRM GraphQL connection...');
+  const isConnected = await client.testConnection();
+  if (!isConnected) {
+    throw new Error('Failed to connect to Twenty CRM. Check URL and API key.');
+  }
+  console.log('✅ GraphQL connection successful');
+
+  console.log(`📤 Loading ${data.length} records via GraphQL...`);
+
+  // Process in batches
+  for (let i = 0; i < data.length; i += batchSize) {
+    const batch = data.slice(i, i + batchSize);
+    const batchNumber = Math.floor(i / batchSize) + 1;
+    const totalBatches = Math.ceil(data.length / batchSize);
+
+    try {
+      progressBar.update((i / data.length) * 100, {
+        batch: `${batchNumber}/${totalBatches}`,
+        records: `${i + 1}-${Math.min(i + batchSize, data.length)}`
+      });
+
+      const batchResult = await client.createRecords(objectType, batch);
+      
+      if (batchResult.success) {
+        successCount += batchResult.count;
+        console.log(`✅ Batch ${batchNumber} imported successfully`);
+      } else {
+        errorCount += batch.length;
+        const errorMsg = `Batch ${batchNumber}: ${batchResult.error}`;
+        errorLog.push(errorMsg);
+        console.error(`❌ ${errorMsg}`);
+      }
+    } catch (error: any) {
+      const errorMsg = `Batch ${batchNumber}: ${error.message}`;
+      errorLog.push(errorMsg);
+      errorCount += batch.length;
+    }
+
+    // Small delay to avoid rate limiting
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+
+  return {
+    success: successCount,
+    errors: errorCount,
+    errorLog
+  };
+}
+
+export function saveErrorLog(errorLog: string[], filename: string): void {
+  if (errorLog.length === 0) return;
+  
+  const logContent = errorLog.join('\n');
+  fs.writeFileSync(filename, logContent, 'utf8');
+  console.log(`📄 Error log saved to ${filename}`);
+}

package/src/load-old.ts

@@ -0,0 +1,177 @@
+import axios, { AxiosInstance } from 'axios';
+import { ParsedRecord } from './parser';
+import * as fs from 'fs';
+
+export interface LoadResult {
+  success: number;
+  errors: number;
+  errorLog: string[];
+}
+
+export interface BatchResult {
+  success: boolean;
+  count: number;
+  error?: string;
+}
+
+export class TwentyAPIClient {
+  private client: AxiosInstance;
+  private baseUrl: string;
+  private apiKey: string;
+
+  constructor(baseUrl: string, apiKey: string) {
+    this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+    this.apiKey = apiKey;
+    
+    this.client = axios.create({
+      baseURL: `${this.baseUrl}/rest`,
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json'
+      },
+      timeout: 30000
+    });
+  }
+
+  async testConnection(): Promise<boolean> {
+    try {
+      const response = await this.client.get('/people', { params: { limit: 1 } });
+      return response.status === 200;
+    } catch (error) {
+      console.error('❌ Connection test failed:', (error as any).response?.data || (error as any).message);
+      return false;
+    }
+  }
+
+  async createRecords(objectType: string, records: ParsedRecord[]): Promise<BatchResult> {
+    try {
+      const response = await this.client.post(`/${objectType}`, {
+        data: records
+      });
+
+      return {
+        success: true,
+        count: records.length
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        count: 0,
+        error: error.response?.data?.message || error.message
+      };
+    }
+  }
+
+  async createRecord(objectType: string, record: ParsedRecord): Promise<BatchResult> {
+    try {
+      const response = await this.client.post(`/${objectType}`, record);
+      return {
+        success: true,
+        count: 1
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        count: 0,
+        error: error.response?.data?.message || error.message
+      };
+    }
+  }
+
+  getObjectEndpoint(objectType: string): string {
+    const endpoints: { [key: string]: string } = {
+      'people': 'people',
+      'persons': 'people',
+      'contacts': 'people',
+      'companies': 'companies',
+      'organization': 'companies',
+      'opportunities': 'opportunities',
+      'deals': 'opportunities',
+      'tasks': 'tasks',
+      'notes': 'notes'
+    };
+    
+    return endpoints[objectType.toLowerCase()] || objectType;
+  }
+}
+
+export async function loadToTwenty(
+  data: ParsedRecord[],
+  objectType: string,
+  twentyUrl: string,
+  twentyKey: string,
+  batchSize: number,
+  progressBar: any
+): Promise<LoadResult> {
+  const client = new TwentyAPIClient(twentyUrl, twentyKey);
+  const errorLog: string[] = [];
+  let successCount = 0;
+  let errorCount = 0;
+
+  // Test connection first
+  console.log('🔗 Testing Twenty CRM connection...');
+  const isConnected = await client.testConnection();
+  if (!isConnected) {
+    throw new Error('Failed to connect to Twenty CRM. Check URL and API key.');
+  }
+  console.log('✅ Connection successful');
+
+  const endpoint = client.getObjectEndpoint(objectType);
+  console.log(`📤 Loading ${data.length} records to ${endpoint}...`);
+
+  // Process in batches
+  for (let i = 0; i < data.length; i += batchSize) {
+    const batch = data.slice(i, i + batchSize);
+    const batchNumber = Math.floor(i / batchSize) + 1;
+    const totalBatches = Math.ceil(data.length / batchSize);
+
+    try {
+      progressBar.update((i / data.length) * 100, {
+        batch: `${batchNumber}/${totalBatches}`,
+        records: `${i + 1}-${Math.min(i + batchSize, data.length)}`
+      });
+
+      // Try batch create first (if supported)
+      const batchResult = await client.createRecords(endpoint, batch);
+      
+      if (batchResult.success) {
+        successCount += batchResult.count;
+      } else {
+        // Fallback to individual records
+        console.warn(`⚠️ Batch create failed, trying individual records...`);
+        
+        for (const record of batch) {
+          const result = await client.createRecord(endpoint, record);
+          if (result.success) {
+            successCount++;
+          } else {
+            errorCount++;
+            const errorMsg = `Record ${JSON.stringify(record)}: ${result.error}`;
+            errorLog.push(errorMsg);
+          }
+        }
+      }
+    } catch (error: any) {
+      const errorMsg = `Batch ${batchNumber}: ${error.message}`;
+      errorLog.push(errorMsg);
+      errorCount += batch.length;
+    }
+
+    // Small delay to avoid rate limiting
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+
+  return {
+    success: successCount,
+    errors: errorCount,
+    errorLog
+  };
+}
+
+export function saveErrorLog(errorLog: string[], filename: string): void {
+  if (errorLog.length === 0) return;
+  
+  const logContent = errorLog.join('\n');
+  fs.writeFileSync(filename, logContent, 'utf8');
+  console.log(`📄 Error log saved to ${filename}`);
+}