@burgan-tech/vnext-workflow-cli 1.0.1 → 1.0.2

package/src/commands/update.js

@@ -3,200 +3,318 @@ const ora = require('ora');
 const path = require('path');
 const inquirer = require('inquirer');
 const config = require('../lib/config');
-const { discoverComponents } = require('../lib/discover');
-const { reinitializeSystem } = require('../lib/api');
-const {
-  processWorkflow,
-  getGitChangedJson,
-  findAllJson
-} = require('../lib/workflow');
-const {
-  processCsxFile,
-  getGitChangedCsx,
-  findAllCsx
-} = require('../lib/csx');
+const { discoverComponents, findAllJsonFiles } = require('../lib/discover');
+const { getDomain, getComponentTypes } = require('../lib/vnextConfig');
+const { publishComponent, reinitializeSystem } = require('../lib/api');
+const { getInstanceId, deleteWorkflow } = require('../lib/db');
+const { getJsonMetadata, getGitChangedJson, findAllJson, detectComponentType } = require('../lib/workflow');
+const { processCsxFile, getGitChangedCsx, findAllCsx } = require('../lib/csx');
+
+// Logging helpers
+const LOG = {
+  separator: () => console.log(chalk.cyan('═'.repeat(60))),
+  subSeparator: () => console.log(chalk.cyan('─'.repeat(60))),
+  header: (text) => {
+    console.log();
+    LOG.separator();
+    console.log(chalk.cyan.bold(`  ${text}`));
+    LOG.separator();
+  },
+  success: (text) => console.log(chalk.green(`  ✓ ${text}`)),
+  error: (text) => console.log(chalk.red(`  ✗ ${text}`)),
+  warning: (text) => console.log(chalk.yellow(`  ⚠ ${text}`)),
+  info: (text) => console.log(chalk.dim(`  ○ ${text}`)),
+  component: (type, name, status, detail = '') => {
+    const typeLabel = chalk.cyan(`[${type}]`);
+    const nameLabel = chalk.white(name);
+    if (status === 'success') {
+      console.log(`  ${typeLabel} ${chalk.green('✓')} ${nameLabel} ${chalk.dim(detail)}`);
+    } else if (status === 'error') {
+      console.log(`  ${typeLabel} ${chalk.red('✗')} ${nameLabel}`);
+      if (detail) console.log(chalk.red(`    └─ ${detail}`));
+    } else if (status === 'skip') {
+      console.log(`  ${typeLabel} ${chalk.dim('○')} ${nameLabel} ${chalk.dim(detail)}`);
+    }
+  }
+};
 
 async function updateCommand(options) {
-  console.log(chalk.cyan.bold('\n🔄 Workflow Güncelleme\n'));
+  LOG.header('COMPONENT UPDATE');
   
   const projectRoot = config.get('PROJECT_ROOT');
   const autoDiscover = config.get('AUTO_DISCOVER');
   
+  // Get domain from vnext.config.json
+  let domain;
+  try {
+    domain = getDomain(projectRoot);
+  } catch (error) {
+    LOG.error(`Failed to read vnext.config.json: ${error.message}`);
+    return;
+  }
+  
   // DB Config
+  const useDockerValue = config.get('USE_DOCKER');
   const dbConfig = {
     host: config.get('DB_HOST'),
     port: config.get('DB_PORT'),
     database: config.get('DB_NAME'),
     user: config.get('DB_USER'),
     password: config.get('DB_PASSWORD'),
-    useDocker: config.get('USE_DOCKER'),
+    useDocker: useDockerValue === true || useDockerValue === 'true',
     dockerContainer: config.get('DOCKER_POSTGRES_CONTAINER')
   };
   
   // API Config
   const apiConfig = {
     baseUrl: config.get('API_BASE_URL'),
-    version: config.get('API_VERSION')
+    version: config.get('API_VERSION'),
+    domain: domain
   };
   
-  // ÖNCELİKLE: Değişen CSX dosyalarını güncelle
+  console.log(chalk.dim(`  Domain: ${domain}`));
+  console.log(chalk.dim(`  API: ${apiConfig.baseUrl}`));
+  console.log();
+  
+  // FIRST: Update changed CSX files
   let csxFiles = [];
+  const csxResults = { success: 0, failed: 0, errors: [] };
   
   if (options.all) {
-    // Tüm CSX'leri bul
-    const csxSpinner = ora('Tüm CSX dosyaları bulunuyor...').start();
-    csxFiles = await findAllCsx(projectRoot);
-    csxSpinner.succeed(chalk.green(`${csxFiles.length} CSX dosyası bulundu`));
+    // Find all CSX files
+    const csxSpinner = ora('Finding all CSX files...').start();
+    try {
+      csxFiles = await findAllCsx(projectRoot);
+      csxSpinner.succeed(chalk.green(`${csxFiles.length} CSX files found`));
+    } catch (error) {
+      csxSpinner.warn(chalk.yellow(`CSX scan error: ${error.message}`));
+    }
   } else {
-    // Git'te değişen CSX'leri bul
-    const csxSpinner = ora('Git\'te değişen CSX dosyaları aranıyor...').start();
-    csxFiles = await getGitChangedCsx(projectRoot);
-    
-    if (csxFiles.length > 0) {
-      csxSpinner.succeed(chalk.green(`${csxFiles.length} değişen CSX dosyası bulundu`));
-    } else {
-      csxSpinner.info(chalk.dim('Değişen CSX dosyası yok'));
+    // Find changed CSX files in Git
+    const csxSpinner = ora('Finding changed CSX files in Git...').start();
+    try {
+      csxFiles = await getGitChangedCsx(projectRoot);
+      
+      if (csxFiles.length > 0) {
+        csxSpinner.succeed(chalk.green(`${csxFiles.length} changed CSX files found`));
+      } else {
+        csxSpinner.info(chalk.dim('No changed CSX files'));
+      }
+    } catch (error) {
+      csxSpinner.warn(chalk.yellow(`CSX scan error: ${error.message}`));
     }
   }
   
-  // CSX dosyalarını güncelle
+  // Update CSX files
   if (csxFiles.length > 0) {
-    console.log(chalk.blue('\n📝 CSX dosyaları JSON\'lara yazılıyor...\n'));
+    console.log(chalk.blue('\n  Writing CSX files to JSONs...\n'));
     
-    let csxSuccessCount = 0;
     for (const csxFile of csxFiles) {
       const fileName = path.basename(csxFile);
-      const csxSpinner = ora(`Base64 encode: ${fileName}`).start();
       
       try {
         const result = await processCsxFile(csxFile, projectRoot);
         
         if (result.success) {
-          csxSpinner.succeed(chalk.green(`✓ ${fileName} → ${result.updatedCount} JSON`));
-          csxSuccessCount++;
+          LOG.component('CSX', fileName, 'success', `→ ${result.updatedJsonCount} JSON, ${result.totalUpdates} refs`);
+          csxResults.success++;
         } else {
-          csxSpinner.warn(chalk.yellow(`○ ${fileName} → ${result.message}`));
+          LOG.component('CSX', fileName, 'skip', result.message);
         }
       } catch (error) {
-        csxSpinner.fail(chalk.red(`✗ ${fileName} → ${error.message}`));
+        LOG.component('CSX', fileName, 'error', error.message);
+        csxResults.failed++;
+        csxResults.errors.push({ file: fileName, error: error.message });
       }
     }
-    
-    if (csxSuccessCount > 0) {
-      console.log(chalk.green(`\n✓ ${csxSuccessCount} CSX dosyası güncellendi\n`));
-    }
   }
   
   let jsonFiles = [];
   
-  // Hangi JSON dosyalarını işleyeceğiz?
+  // Which JSON files to process?
   if (options.file) {
-    // Belirli dosya
+    // Specific file
     const filePath = path.isAbsolute(options.file) 
       ? options.file 
       : path.join(projectRoot, options.file);
-    jsonFiles = [filePath];
-    console.log(chalk.blue(`Dosya: ${path.basename(filePath)}\n`));
+    jsonFiles = [{ path: filePath, type: detectComponentType(filePath, projectRoot), fileName: path.basename(filePath) }];
+    console.log(chalk.blue(`\n  File: ${path.basename(filePath)}\n`));
   } else if (options.all) {
-    // Tüm JSON dosyaları
-    console.log(chalk.yellow('⚠️  TÜM workflow\'lar güncellenecek!\n'));
+    // All JSON files
+    LOG.warning('ALL components will be updated!');
+    console.log();
     
     const { confirm } = await inquirer.prompt([{
       type: 'confirm',
       name: 'confirm',
-      message: 'Devam edilsin mi?',
+      message: 'Continue?',
       default: false
     }]);
     
     if (!confirm) {
-      console.log(chalk.yellow('\nİşlem iptal edildi.\n'));
+      LOG.warning('Operation cancelled.');
+      console.log();
       return;
     }
     
-    const spinner = ora('Tüm JSON dosyaları bulunuyor...').start();
+    const spinner = ora('Finding all JSON files...').start();
     
     if (autoDiscover) {
       const discovered = await discoverComponents(projectRoot);
-      jsonFiles = await findAllJson(discovered);
-    } else {
-      // Fallback
-      jsonFiles = [];
+      const files = await findAllJson(discovered);
+      jsonFiles = files.map(f => ({
+        path: f,
+        type: detectComponentType(f, projectRoot),
+        fileName: path.basename(f)
+      }));
     }
     
-    spinner.succeed(chalk.green(`${jsonFiles.length} JSON dosyası bulundu`));
+    spinner.succeed(chalk.green(`${jsonFiles.length} JSON files found`));
   } else {
-    // Git'te değişenler (default)
-    const spinner = ora('Git\'te değişen JSON dosyaları aranıyor...').start();
-    jsonFiles = await getGitChangedJson(projectRoot);
+    // Changed files in Git (default)
+    const spinner = ora('Finding changed JSON files in Git...').start();
+    const changedFiles = await getGitChangedJson(projectRoot);
     
-    if (jsonFiles.length === 0) {
-      spinner.info(chalk.yellow('Git\'te değişen JSON dosyası bulunamadı'));
-      console.log(chalk.green('\n✓ Tüm workflow\'lar güncel\n'));
+    if (changedFiles.length === 0) {
+      spinner.info(chalk.yellow('No changed JSON files in Git'));
+      console.log(chalk.green('\n  ✓ All components up to date\n'));
       return;
     }
     
-    spinner.succeed(chalk.green(`${jsonFiles.length} değişen JSON dosyası bulundu`));
+    jsonFiles = changedFiles.map(f => ({
+      path: f,
+      type: detectComponentType(f, projectRoot),
+      fileName: path.basename(f)
+    }));
+    
+    spinner.succeed(chalk.green(`${jsonFiles.length} changed JSON files found`));
   }
   
-  // Her JSON dosyasını işle
-  let successCount = 0;
-  let failCount = 0;
+  // Group by component type
+  const componentStats = {};
+  const errors = [];
   
-  console.log();
-  for (const jsonFile of jsonFiles) {
-    const fileName = path.basename(jsonFile);
-    const spinner = ora(`İşleniyor: ${fileName}`).start();
+  console.log(chalk.blue('\n  Publishing components...\n'));
+  
+  for (const jsonInfo of jsonFiles) {
+    const { path: jsonPath, type, fileName } = jsonInfo;
+    
+    // Initialize stats
+    if (!componentStats[type]) {
+      componentStats[type] = { success: 0, failed: 0, skipped: 0, updated: 0, created: 0 };
+    }
     
     try {
-      const result = await processWorkflow(jsonFile, dbConfig, apiConfig);
+      const metadata = await getJsonMetadata(jsonPath);
       
-      const status = result.wasDeleted ? 'güncellendi' : 'oluşturuldu';
-      spinner.succeed(chalk.green(`✓ ${fileName} → ${status}`));
-      successCount++;
-    } catch (error) {
-      let errorMsg = error.message;
-      if (error.response?.data) {
-        if (typeof error.response.data === 'string') {
-          errorMsg = error.response.data;
-        } else if (error.response.data.error?.message) {
-          errorMsg = error.response.data.error.message;
-        } else if (error.response.data.message) {
-          errorMsg = error.response.data.message;
+      if (!metadata.key || !metadata.version) {
+        LOG.component(type, fileName, 'skip', 'no key/version');
+        componentStats[type].skipped++;
+        continue;
+      }
+      
+      // Detect flow type
+      const flow = metadata.flow || detectComponentType(jsonPath, projectRoot);
+      
+      // Check if exists in DB
+      const existingId = await getInstanceId(dbConfig, flow, metadata.key, metadata.version);
+      
+      // If exists, delete first
+      let wasDeleted = false;
+      if (existingId) {
+        await deleteWorkflow(dbConfig, flow, existingId);
+        wasDeleted = true;
+      }
+      
+      // Publish to API
+      const result = await publishComponent(apiConfig.baseUrl, metadata.data);
+      
+      if (result.success) {
+        if (wasDeleted) {
+          LOG.component(type, fileName, 'success', '→ updated');
+          componentStats[type].updated++;
         } else {
-          errorMsg = JSON.stringify(error.response.data);
+          LOG.component(type, fileName, 'success', '→ created');
+          componentStats[type].created++;
         }
+        componentStats[type].success++;
+      } else {
+        LOG.component(type, fileName, 'error', result.error);
+        componentStats[type].failed++;
+        errors.push({ type, file: fileName, error: result.error });
       }
-      spinner.fail(chalk.red(`✗ ${fileName} → ${errorMsg}`));
-      failCount++;
+    } catch (error) {
+      const errorMsg = error.message || 'Unknown error';
+      LOG.component(type, fileName, 'error', errorMsg);
+      componentStats[type].failed++;
+      errors.push({ type, file: fileName, error: errorMsg });
     }
   }
   
   // Re-initialize
-  if (successCount > 0) {
+  const totalSuccess = Object.values(componentStats).reduce((sum, s) => sum + s.success, 0);
+  
+  if (totalSuccess > 0) {
     console.log();
-    const reinitSpinner = ora('Sistem yeniden başlatılıyor...').start();
+    const reinitSpinner = ora('Re-initializing system...').start();
     const reinitSuccess = await reinitializeSystem(apiConfig.baseUrl, apiConfig.version);
     
     if (reinitSuccess) {
-      reinitSpinner.succeed(chalk.green('✓ Sistem yenilendi'));
+      reinitSpinner.succeed(chalk.green('System re-initialized'));
     } else {
-      reinitSpinner.warn(chalk.yellow('⚠ Sistem yenilenemedi (devam edildi)'));
+      reinitSpinner.warn(chalk.yellow('System re-initialization failed (continuing)'));
     }
   }
   
-  // Özet
-  console.log();
-  console.log(chalk.cyan('═'.repeat(50)));
-  console.log(chalk.white(`Toplam: ${jsonFiles.length} dosya`));
-  console.log(chalk.green(`✓ Başarılı: ${successCount}`));
-  if (failCount > 0) {
-    console.log(chalk.red(`✗ Başarısız: ${failCount}`));
+  // SUMMARY REPORT
+  LOG.header('UPDATE SUMMARY');
+  
+  // Component statistics
+  console.log(chalk.white.bold('\n  Component Update Results:\n'));
+  
+  for (const [type, stats] of Object.entries(componentStats)) {
+    const updatedLabel = stats.updated > 0 ? chalk.green(`${stats.updated} updated`) : '';
+    const createdLabel = stats.created > 0 ? chalk.green(`${stats.created} created`) : '';
+    const failedLabel = stats.failed > 0 ? chalk.red(`${stats.failed} failed`) : '';
+    const skippedLabel = stats.skipped > 0 ? chalk.dim(`${stats.skipped} skipped`) : '';
+    
+    const parts = [updatedLabel, createdLabel, failedLabel, skippedLabel].filter(Boolean);
+    console.log(`  ${chalk.cyan(type.padEnd(12))} : ${parts.join(', ') || chalk.dim('0')}`);
   }
-  console.log(chalk.cyan('═'.repeat(50)));
-  console.log();
   
-  if (successCount > 0) {
-    console.log(chalk.green.bold('✓ Workflow güncelleme tamamlandı\n'));
+  // CSX summary
+  if (csxFiles.length > 0) {
+    console.log();
+    const csxSuccessLabel = csxResults.success > 0 ? chalk.green(`${csxResults.success} success`) : chalk.dim('0 success');
+    const csxFailedLabel = csxResults.failed > 0 ? chalk.red(`, ${csxResults.failed} failed`) : '';
+    console.log(`  ${chalk.cyan('CSX'.padEnd(12))} : ${csxSuccessLabel}${csxFailedLabel}`);
+  }
+  
+  // Errors
+  if (errors.length > 0 || csxResults.errors.length > 0) {
+    console.log();
+    LOG.subSeparator();
+    console.log(chalk.red.bold('\n  ERRORS:\n'));
+    
+    for (const err of errors) {
+      console.log(chalk.red(`  [${err.type}] ${err.file}`));
+      console.log(chalk.dim(`    └─ ${err.error}`));
+    }
+    
+    for (const err of csxResults.errors) {
+      console.log(chalk.red(`  [CSX] ${err.file}`));
+      console.log(chalk.dim(`    └─ ${err.error}`));
+    }
+  }
+  
+  LOG.separator();
+  
+  const totalFailed = Object.values(componentStats).reduce((sum, s) => sum + s.failed, 0) + csxResults.failed;
+  
+  if (totalSuccess > 0 && totalFailed === 0) {
+    console.log(chalk.green.bold('\n  ✓ Update completed\n'));
+  } else if (totalFailed > 0) {
+    console.log(chalk.yellow.bold(`\n  ⚠ Update completed (${totalFailed} errors)\n`));
   }
 }
 

package/src/lib/api.js

@@ -2,6 +2,8 @@ const axios = require('axios');
 
 /**
  * API bağlantısını test eder
+ * @param {string} baseUrl - API base URL
+ * @returns {Promise<boolean>} Bağlantı durumu
  */
 async function testApiConnection(baseUrl) {
   try {
@@ -15,46 +17,64 @@ async function testApiConnection(baseUrl) {
 }
 
 /**
- * Workflow'u API'ye post eder
+ * Komponenti API'ye publish eder
+ * @param {string} baseUrl - API base URL
+ * @param {Object} componentData - Komponent JSON verisi
+ * @returns {Promise<Object>} API response
  */
-async function postWorkflow(baseUrl, version, flow, data) {
-  const domain = 'core'; // API_DOMAIN
-  const workflowVersion = data.version || '1.0.0';
-  const syncMode = 'true';
+async function publishComponent(baseUrl, componentData) {
+  const url = `${baseUrl}/api/v1/definitions/publish`;
   
-  const url = `${baseUrl}/api/${version}/${domain}/workflows/${flow}/instances/start?version=${workflowVersion}&sync=${syncMode}`;
-  
-  const response = await axios.post(url, data, {
-    headers: {
-      'accept': '*/*',
-      'Content-Type': 'application/json'
-    }
-  });
-  return response.data;
-}
-
-/**
- * Workflow'u aktif eder
- */
-async function activateWorkflow(baseUrl, version, flow, instanceId, workflowVersion) {
-  const domain = 'core'; // API_DOMAIN
-  const syncMode = 'true';
-  
-  const url = `${baseUrl}/api/${version}/${domain}/workflows/${flow}/instances/${instanceId}/transitions/activate?version=${workflowVersion}&sync=${syncMode}`;
-  
-  const response = await axios.patch(url, null, {
-    headers: {
-      'accept': '*/*'
+  try {
+    const response = await axios.post(url, componentData, {
+      headers: {
+        'accept': '*/*',
+        'Content-Type': 'application/json'
+      },
+      timeout: 30000
+    });
+    
+    return {
+      success: true,
+      data: response.data
+    };
+  } catch (error) {
+    // API hata detaylarını çıkar
+    let errorMessage = error.message;
+    let errorDetails = null;
+    
+    if (error.response) {
+      const responseData = error.response.data;
+      
+      if (typeof responseData === 'string') {
+        errorMessage = responseData;
+      } else if (responseData?.error?.message) {
+        errorMessage = responseData.error.message;
+        errorDetails = responseData.error;
+      } else if (responseData?.message) {
+        errorMessage = responseData.message;
+      } else if (responseData) {
+        errorMessage = JSON.stringify(responseData);
+      }
     }
-  });
-  return response.data;
+    
+    return {
+      success: false,
+      error: errorMessage,
+      errorDetails: errorDetails,
+      statusCode: error.response?.status
+    };
+  }
 }
 
 /**
  * Sistemi yeniden başlatır
+ * @param {string} baseUrl - API base URL
+ * @param {string} version - API version
+ * @returns {Promise<boolean>} Başarı durumu
  */
 async function reinitializeSystem(baseUrl, version) {
-  const url = `${baseUrl}/api/${version}/admin/re-initialize`;
+  const url = `${baseUrl}/api/${version}/definitions/re-initialize`;
   try {
     await axios.get(url, { timeout: 10000 });
     return true;
@@ -65,8 +85,6 @@ async function reinitializeSystem(baseUrl, version) {
 
 module.exports = {
   testApiConnection,
-  postWorkflow,
-  activateWorkflow,
+  publishComponent,
   reinitializeSystem
 };
-

package/src/lib/config.js

@@ -4,7 +4,6 @@ const path = require('path');
 const config = new Conf({
   projectName: 'vnext-workflow-cli',
   defaults: {
-    PROJECT_ROOT: process.cwd(),
     AUTO_DISCOVER: true,
     API_BASE_URL: 'http://localhost:4201',
     API_VERSION: 'v1',
@@ -19,11 +18,50 @@ const config = new Conf({
   }
 });
 
+/**
+ * Gets a config value
+ * PROJECT_ROOT always returns current working directory (process.cwd())
+ * @param {string} key - Config key
+ * @returns {any} Config value
+ */
+function get(key) {
+  // PROJECT_ROOT is always the current working directory
+  if (key === 'PROJECT_ROOT') {
+    return process.cwd();
+  }
+  return config.get(key);
+}
+
+/**
+ * Sets a config value
+ * PROJECT_ROOT cannot be set (ignored)
+ * @param {string} key - Config key
+ * @param {any} value - Config value
+ */
+function set(key, value) {
+  // PROJECT_ROOT cannot be saved - always uses cwd
+  if (key === 'PROJECT_ROOT') {
+    console.log('Note: PROJECT_ROOT is always the current working directory and cannot be changed.');
+    return;
+  }
+  config.set(key, value);
+}
+
+/**
+ * Gets all config values including PROJECT_ROOT
+ * @returns {Object} All config values
+ */
+function getAll() {
+  return {
+    PROJECT_ROOT: process.cwd(),
+    ...config.store
+  };
+}
+
 module.exports = {
-  get: (key) => config.get(key),
-  set: (key, value) => config.set(key, value),
-  getAll: () => config.store,
+  get,
+  set,
+  getAll,
   clear: () => config.clear(),
   path: config.path
 };
-