twenty-import-csv 1.0.0

package/src/load-real.ts

@@ -0,0 +1,199 @@
+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 TwentyRealAPIClient {
+  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 {
+      // Проверяем health endpoint
+      const response = await this.client.get('/api/ping');
+      return response.status === 200;
+    } catch (error: any) {
+      console.error('❌ Connection test failed:', error.response?.data || error.message);
+      return false;
+    }
+  }
+
+  async createRecords(objectType: string, records: ParsedRecord[]): Promise<BatchResult> {
+    try {
+      // Пробуем разные реальные endpoints Twenty CRM
+      const endpoints = [
+        `/api/${objectType}`,
+        `/api/v1/${objectType}`,
+        `/api/rest/${objectType}`,
+        `/v1/${objectType}`,
+        `/${objectType}`
+      ];
+
+      for (const endpoint of endpoints) {
+        try {
+          console.log(`🔍 Пробуем endpoint: ${endpoint}`);
+          
+          // Формат payload для Twenty CRM
+          const payload = records.map(record => {
+            const transformed: any = {};
+            
+            if (objectType === 'people') {
+              // Пробуем разные форматы name
+              if (record['name.firstName'] || record['name.lastName']) {
+                transformed.name = {
+                  firstName: record['name.firstName'] || '',
+                  lastName: record['name.lastName'] || ''
+                };
+              }
+              
+              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(endpoint, payload);
+          
+          console.log(`✅ Endpoint ${endpoint} работает!`);
+          return {
+            success: true,
+            count: records.length
+          };
+          
+        } catch (error: any) {
+          console.log(`❌ Endpoint ${endpoint} не работает:`, error.response?.status);
+          if (error.response?.status !== 404) {
+            // Если это не 404, пробуем следующий endpoint
+            continue;
+          }
+        }
+      }
+      
+      throw new Error(`Не найден рабочий endpoint для ${objectType}`);
+      
+    } 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 TwentyRealAPIClient(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');
+
+  console.log(`📤 Loading ${data.length} records to Twenty CRM...`);
+
+  // 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.ts

@@ -0,0 +1,197 @@
+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: any) {
+      console.error('❌ Connection test failed:', error.response?.data || error.message);
+      return false;
+    }
+  }
+
+  async createRecords(objectType: string, records: ParsedRecord[]): Promise<BatchResult> {
+    try {
+      // Try different payload formats
+      let payload;
+      
+      // Format 1: { data: records }
+      payload = { data: records };
+      
+      // Format 2: records directly
+      // payload = records;
+      
+      // Format 3: { records: records }
+      // payload = { records: records };
+
+      console.log('🔍 Debug - Payload format:', JSON.stringify(payload, null, 2));
+      console.log('🔍 Debug - Payload length:', JSON.stringify(payload).length);
+
+      const response = await this.client.post(`/${objectType}`, payload);
+      
+      return {
+        success: true,
+        count: records.length
+      };
+    } catch (error: any) {
+      console.error('🔍 Debug - Error response:', error.response?.data);
+      console.error('🔍 Debug - Error status:', error.response?.status);
+      
+      return {
+        success: false,
+        count: 0,
+        error: error.response?.data?.message || error.message
+      };
+    }
+  }
+
+  async createRecord(objectType: string, record: ParsedRecord): Promise<BatchResult> {
+    try {
+      console.log('🔍 Debug - Single record:', JSON.stringify(record, null, 2));
+      
+      const response = await this.client.post(`/${objectType}`, record);
+      return {
+        success: true,
+        count: 1
+      };
+    } catch (error: any) {
+      console.error('🔍 Debug - Single record error:', error.response?.data);
+      
+      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
+      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}`);
+}

package/src/mapper.ts

@@ -0,0 +1,183 @@
+import * as fs from 'fs';
+import * as readline from 'readline';
+import { ParsedRecord } from './parser';
+
+export interface FieldMapping {
+  [csvField: string]: string;
+}
+
+export interface TwentyObjectFields {
+  people: string[];
+  companies: string[];
+  opportunities: string[];
+  tasks: string[];
+  notes: string[];
+}
+
+// Twenty CRM API field mappings
+const TWENTY_FIELDS: TwentyObjectFields = {
+  people: [
+    'name.firstName', 'name.lastName', 'email', 'phone', 'jobTitle',
+    'city', 'country', 'linkedinUrl', 'avatarUrl', 'note'
+  ],
+  companies: [
+    'name', 'domainName', 'employees', 'annualRevenue', 'industry',
+    'linkedinUrl', 'phone', 'address', 'city', 'country'
+  ],
+  opportunities: [
+    'name', 'amount', 'currency', 'stage', 'probability',
+    'closeDate', 'description', 'companyId', 'personId'
+  ],
+  tasks: [
+    'title', 'description', 'status', 'dueDate', 'assigneeId',
+    'companyId', 'personId', 'priority'
+  ],
+  notes: [
+    'body', 'authorId', 'companyId', 'personId', 'opportunityId'
+  ]
+};
+
+export async function loadMapping(mappingFile: string): Promise<FieldMapping> {
+  return new Promise((resolve, reject) => {
+    const mapping: FieldMapping = {};
+    
+    if (!fs.existsSync(mappingFile)) {
+      reject(new Error(`Mapping file ${mappingFile} not found`));
+      return;
+    }
+
+    const rl = readline.createInterface({
+      input: fs.createReadStream(mappingFile),
+      crlfDelay: Infinity
+    });
+
+    rl.on('line', (line) => {
+      const [csvField, twentyField] = line.split('=').map(s => s.trim());
+      if (csvField && twentyField) {
+        mapping[csvField] = twentyField;
+      }
+    });
+
+    rl.on('close', () => {
+      resolve(mapping);
+    });
+
+    rl.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+export async function mapFields(
+  data: ParsedRecord[], 
+  objectType: string, 
+  mapping?: FieldMapping
+): Promise<ParsedRecord[]> {
+  const validFields = TWENTY_FIELDS[objectType as keyof TwentyObjectFields];
+  
+  if (!validFields) {
+    throw new Error(`Unknown object type: ${objectType}`);
+  }
+
+  return data.map(record => {
+    const mapped: ParsedRecord = {};
+    
+    Object.keys(record).forEach(csvField => {
+      const twentyField = mapping ? mapping[csvField] : csvField;
+      
+      // Auto-map common field names
+      const autoMappedField = autoMapField(csvField, objectType);
+      const finalField = twentyField || autoMappedField;
+      
+      if (finalField && validFields.includes(finalField)) {
+        mapped[finalField] = record[csvField];
+      }
+    });
+
+    return mapped;
+  });
+}
+
+function autoMapField(csvField: string, objectType: string): string | null {
+  const field = csvField.toLowerCase();
+  
+  const commonMappings: { [key: string]: { [key: string]: string } } = {
+    people: {
+      'first_name': 'name.firstName',
+      'last_name': 'name.lastName',
+      'firstname': 'name.firstName',
+      'lastname': 'name.lastName',
+      'full_name': 'name.firstName',
+      'email_address': 'email',
+      'phone_number': 'phone',
+      'job_title': 'jobTitle',
+      'company': 'company',
+      'linkedin': 'linkedinUrl',
+      'avatar': 'avatarUrl'
+    },
+    companies: {
+      'company_name': 'name',
+      'company': 'name',
+      'website': 'domainName',
+      'domain': 'domainName',
+      'employee_count': 'employees',
+      'revenue': 'annualRevenue',
+      'address_line': 'address',
+      'zip_code': 'zipCode'
+    },
+    opportunities: {
+      'deal_name': 'name',
+      'deal': 'name',
+      'amount': 'amount',
+      'value': 'amount',
+      'stage': 'stage',
+      'probability': 'probability',
+      'close_date': 'closeDate',
+      'description': 'description'
+    }
+  };
+
+  return commonMappings[objectType]?.[field] || null;
+}
+
+export async function interactiveMapping(
+  data: ParsedRecord[], 
+  objectType: string
+): Promise<FieldMapping> {
+  const mapping: FieldMapping = {};
+  const validFields = TWENTY_FIELDS[objectType as keyof TwentyObjectFields];
+  const detectedFields = Object.keys(data[0] || {});
+
+  console.log(`\n🗺 Interactive Field Mapping for ${objectType}`);
+  console.log(`📋 Available Twenty fields: ${validFields.join(', ')}`);
+  console.log(`📋 Detected CSV fields: ${detectedFields.join(', ')}\n`);
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  for (const csvField of detectedFields) {
+    const answer = await new Promise<string>((resolve) => {
+      rl.question(`Map "${csvField}" -> (field name or skip): `, resolve);
+    });
+
+    if (answer && answer !== 'skip' && validFields.includes(answer)) {
+      mapping[csvField] = answer;
+      console.log(`✅ ${csvField} → ${answer}`);
+    } else if (answer === 'skip') {
+      console.log(`⏭️ Skipping ${csvField}`);
+    } else {
+      console.log(`❌ Invalid field. Skipping ${csvField}`);
+    }
+  }
+
+  rl.close();
+  return mapping;
+}
+
+export function saveMapping(mapping: FieldMapping, outputFile: string): void {
+  const lines = Object.entries(mapping).map(([csv, twenty]) => `${csv}=${twenty}`);
+  fs.writeFileSync(outputFile, lines.join('\n'), 'utf8');
+  console.log(`💾 Mapping saved to ${outputFile}`);
+}

package/src/parser.ts

@@ -0,0 +1,55 @@
+import { readFileSync, statSync } from 'fs';
+import { basename } from 'path';
+import * as Papa from 'papaparse';
+
+export interface ParsedRecord {
+  [key: string]: any;
+}
+
+export async function parseCSV(filePath: string): Promise<ParsedRecord[]> {
+  return new Promise((resolve, reject) => {
+    Papa.parse(readFileSync(filePath, 'utf8'), {
+      header: true,
+      skipEmptyLines: true,
+      complete: (results) => {
+        if (results.errors.length > 0) {
+          console.warn(`⚠️ CSV parsing warnings: ${results.errors.length}`);
+          results.errors.forEach((error: any) => {
+            console.warn(`  Row ${error.row}: ${error.message}`);
+          });
+        }
+        
+        resolve(results.data as ParsedRecord[]);
+      },
+      error: (error: any) => {
+        reject(new Error(`CSV parsing failed: ${error.message}`));
+      }
+    });
+  });
+}
+
+export function detectColumns(data: ParsedRecord[]): string[] {
+  if (data.length === 0) return [];
+  
+  const allFields = new Set<string>();
+  
+  data.forEach(record => {
+    Object.keys(record).forEach(key => {
+      if (record[key] !== null && record[key] !== undefined && record[key] !== '') {
+        allFields.add(key);
+      }
+    });
+  });
+  
+  return Array.from(allFields).sort();
+}
+
+export function getFileInfo(filePath: string): { name: string; size: number; rows: number } {
+  const stats = statSync(filePath);
+  
+  return {
+    name: basename(filePath),
+    size: stats.size,
+    rows: 0 // Will be updated after parsing
+  };
+}