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

package/src/commands/domain.js

@@ -0,0 +1,161 @@
+const chalk = require('chalk');
+const config = require('../lib/config');
+
+const VALID_KEYS = [
+  'API_BASE_URL', 'API_VERSION', 'DB_HOST', 'DB_PORT', 'DB_NAME',
+  'DB_USER', 'DB_PASSWORD', 'AUTO_DISCOVER', 'USE_DOCKER',
+  'DOCKER_POSTGRES_CONTAINER', 'DEBUG_MODE'
+];
+
+const NUMERIC_KEYS = ['DB_PORT'];
+const BOOLEAN_KEYS = ['AUTO_DISCOVER', 'USE_DOCKER', 'DEBUG_MODE'];
+
+/**
+ * Coerces a string value to the correct type based on key.
+ * Only known numeric keys become numbers; only known boolean keys become booleans.
+ * All other values remain as strings.
+ */
+function coerceValue(key, value) {
+  if (BOOLEAN_KEYS.includes(key)) {
+    return value === 'true';
+  }
+  if (NUMERIC_KEYS.includes(key)) {
+    const num = Number(value);
+    return isNaN(num) ? value : num;
+  }
+  return value;
+}
+
+/**
+ * Extracts and coerces valid domain config options from Commander options object.
+ */
+function extractOptions(options) {
+  const parsed = {};
+  for (const key of VALID_KEYS) {
+    if (options[key] !== undefined) {
+      parsed[key] = coerceValue(key, options[key]);
+    }
+  }
+  return parsed;
+}
+
+/**
+ * Main domain command handler.
+ * Dispatches to add, use, list, or remove based on action argument.
+ */
+async function domainCommand(action, name, options) {
+  // Support wf domain --list
+  if (options.list || action === 'list') {
+    return listDomains();
+  }
+
+  if (action === 'active') {
+    return showActiveDomain();
+  }
+
+  if (action === 'add') {
+    return addDomain(name, options);
+  }
+
+  if (action === 'use') {
+    return useDomain(name);
+  }
+
+  if (action === 'remove') {
+    return removeDomain(name);
+  }
+
+  // No valid action - show usage
+  console.log(chalk.cyan.bold('\n🌐 Domain Management\n'));
+  console.log('Usage:');
+  console.log(chalk.white('  wf domain active                                       Show active domain'));
+  console.log(chalk.white('  wf domain list                                         List all domains'));
+  console.log(chalk.white('  wf domain add <name> [--API_BASE_URL ...] [--DB_NAME ...]  Add a domain'));
+  console.log(chalk.white('  wf domain use <name>                                   Switch active domain'));
+  console.log(chalk.white('  wf domain remove <name>                                Remove a domain'));
+  console.log('');
+}
+
+function showActiveDomain() {
+  console.log(config.get('ACTIVE_DOMAIN'));
+}
+
+function addDomain(name, options) {
+  if (!name) {
+    console.log(chalk.red('Usage: wf domain add <name> [--API_BASE_URL <url>] [--DB_NAME <name>] ...'));
+    return;
+  }
+
+  try {
+    const parsed = extractOptions(options);
+    const domain = config.addDomain(name, parsed);
+
+    console.log(chalk.green(`\n✓ Domain "${name}" added successfully.\n`));
+    printDomainConfig(domain);
+  } catch (error) {
+    console.log(chalk.red(`\n✗ Error: ${error.message}\n`));
+  }
+}
+
+function useDomain(name) {
+  if (!name) {
+    console.log(chalk.red('Usage: wf domain use <name>'));
+    return;
+  }
+
+  try {
+    config.useDomain(name);
+    console.log(chalk.green(`\n✓ Active domain switched to "${name}".\n`));
+
+    // Show key applied config values
+    const domainConfig = config.getActiveDomainConfig();
+    console.log(chalk.cyan('Applied settings:'));
+    console.log(chalk.cyan('  API_BASE_URL:'), chalk.white(domainConfig.API_BASE_URL));
+    console.log(chalk.cyan('  DB_NAME:     '), chalk.white(domainConfig.DB_NAME));
+    console.log('');
+  } catch (error) {
+    console.log(chalk.red(`\n✗ Error: ${error.message}\n`));
+  }
+}
+
+function listDomains() {
+  const { activeDomain, domains } = config.listDomains();
+
+  console.log(chalk.cyan.bold('\n🌐 Domains:\n'));
+
+  for (const domain of domains) {
+    const isActive = domain.DOMAIN_NAME === activeDomain;
+    const marker = isActive ? chalk.green('▸ ') : '  ';
+    const label = isActive
+      ? chalk.green.bold(domain.DOMAIN_NAME) + chalk.green(' (active)')
+      : chalk.white(domain.DOMAIN_NAME);
+
+    console.log(`${marker}${label}`);
+    console.log(chalk.dim(`    API: ${domain.API_BASE_URL}  DB: ${domain.DB_NAME}`));
+  }
+
+  console.log('');
+}
+
+function removeDomain(name) {
+  if (!name) {
+    console.log(chalk.red('Usage: wf domain remove <name>'));
+    return;
+  }
+
+  try {
+    config.removeDomain(name);
+    console.log(chalk.green(`\n✓ Domain "${name}" removed.\n`));
+  } catch (error) {
+    console.log(chalk.red(`\n✗ Error: ${error.message}\n`));
+  }
+}
+
+function printDomainConfig(domain) {
+  for (const [key, value] of Object.entries(domain)) {
+    console.log(chalk.cyan(`  ${key}:`), chalk.white(value));
+  }
+  console.log('');
+}
+
+module.exports = domainCommand;

package/src/commands/reset.js

@@ -1,161 +1,279 @@
 const chalk = require('chalk');
 const ora = require('ora');
 const inquirer = require('inquirer');
+const path = require('path');
+const { glob } = require('glob');
 const config = require('../lib/config');
 const { discoverComponents } = require('../lib/discover');
-const { processWorkflow, findAllJson } = require('../lib/workflow');
-const { reinitializeSystem } = require('../lib/api');
+const { getDomain, getComponentTypes } = require('../lib/vnextConfig');
+const { getJsonMetadata, findAllJson, detectComponentType } = require('../lib/workflow');
+const { publishComponent, reinitializeSystem } = require('../lib/api');
+const { getInstanceId, deleteWorkflow } = require('../lib/db');
+
+// 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 resetCommand(options) {
-  console.log(chalk.cyan.bold('\n🔄 Workflow Reset (Force Update)\n'));
+  LOG.header('COMPONENT RESET (Force Update)');
   
   const projectRoot = config.get('PROJECT_ROOT');
-  const autoDiscover = config.get('AUTO_DISCOVER');
+  
+  // Get domain from vnext.config.json
+  let domain, componentTypes;
+  try {
+    domain = getDomain(projectRoot);
+    componentTypes = getComponentTypes(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
   };
   
-  // Klasörleri keşfet
-  const spinner = ora('Klasörler taranıyor...').start();
-  const discovered = await discoverComponents(projectRoot);
-  spinner.succeed(chalk.green('Klasörler bulundu'));
-  
-  // Seçenekler
-  const choices = [
-    { name: '🔵 Workflows (sys-flows)', value: 'Workflows' },
-    { name: '📋 Tasks (sys-tasks)', value: 'Tasks' },
-    { name: '📊 Schemas (sys-schemas)', value: 'Schemas' },
-    { name: '👁️  Views (sys-views)', value: 'Views' },
-    { name: '⚙️  Functions (sys-functions)', value: 'Functions' },
-    { name: '🔌 Extensions (sys-extensions)', value: 'Extensions' },
-    new inquirer.Separator(),
-    { name: '🔴 TÜMÜ (Tüm klasörler)', value: 'ALL' }
-  ];
-  
-  // Kullanıcıdan seç
+  console.log(chalk.dim(`  Domain: ${domain}`));
+  console.log(chalk.dim(`  API: ${apiConfig.baseUrl}`));
+  console.log();
+  
+  // Discover folders
+  const spinner = ora('  Scanning folders...').start();
+  let discovered;
+  try {
+    discovered = await discoverComponents(projectRoot);
+    spinner.succeed(chalk.green('  Folders discovered'));
+  } catch (error) {
+    spinner.fail(chalk.red(`  Folder scan error: ${error.message}`));
+    return;
+  }
+  
+  // Build choices dynamically
+  const choices = [];
+  for (const [type, folderName] of Object.entries(componentTypes)) {
+    if (discovered[type]) {
+      choices.push({ name: `${type} (${folderName}/)`, value: type });
+    }
+  }
+  
+  choices.push(new inquirer.Separator());
+  choices.push({ name: 'ALL (All folders)', value: 'ALL' });
+  
+  // User selection
   const { selected } = await inquirer.prompt([{
     type: 'list',
     name: 'selected',
-    message: 'Hangi klasör resetlensin?',
+    message: 'Which folder to reset?',
     choices: choices
   }]);
   
-  // Dosyaları bul
+  // Find files
   let jsonFiles = [];
   
   if (selected === 'ALL') {
-    jsonFiles = await findAllJson(discovered);
+    const files = await findAllJson(discovered);
+    jsonFiles = files.map(f => ({
+      path: f,
+      type: detectComponentType(f, projectRoot),
+      fileName: path.basename(f)
+    }));
   } else {
     const dir = discovered[selected];
     if (!dir) {
-      console.log(chalk.red(`\n✗ ${selected} klasörü bulunamadı\n`));
+      LOG.error(`${selected} folder not found`);
       return;
     }
     
-    // Sadece bu klasördeki JSON'ları bul
-    const fs = require('fs').promises;
-    const path = require('path');
-    const { glob } = require('glob');
-    
+    // Find JSONs in this folder only
     const pattern = path.join(dir, '**/*.json');
-    jsonFiles = await glob(pattern);
+    const files = await glob(pattern, {
+      ignore: [
+        '**/.meta/**',
+        '**/.meta',
+        '**/*.diagram.json',
+        '**/package*.json',
+        '**/*config*.json'
+      ]
+    });
+    
+    jsonFiles = files.map(f => ({
+      path: f,
+      type: selected,
+      fileName: path.basename(f)
+    }));
   }
   
   if (jsonFiles.length === 0) {
-    console.log(chalk.yellow('\n⚠ JSON dosyası bulunamadı\n'));
+    LOG.warning('No JSON files found');
+    console.log();
     return;
   }
   
-  // Son onay
-  console.log(chalk.yellow(`\n⚠️  ${jsonFiles.length} workflow resetlenecek (DB'den silinip tekrar eklenecek)!\n`));
+  // Final confirmation
+  LOG.warning(`${jsonFiles.length} components will be reset!`);
+  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;
   }
   
-  // İşle
-  let successCount = 0;
-  let failCount = 0;
+  // Group by component type
+  const componentStats = {};
+  const errors = [];
   
-  console.log();
-  for (const jsonFile of jsonFiles) {
-    const fileName = require('path').basename(jsonFile);
-    const spinner = ora(`İşleniyor: ${fileName}`).start();
+  console.log(chalk.blue('\n  Resetting 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, deleted: 0 };
+    }
     
     try {
-      const result = await processWorkflow(jsonFile, dbConfig, apiConfig);
+      const metadata = await getJsonMetadata(jsonPath);
       
-      const status = result.wasDeleted ? 'resetlendi' : '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;
-        } else {
-          errorMsg = JSON.stringify(error.response.data);
-        }
+      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 (force reset)
+      let wasDeleted = false;
+      if (existingId) {
+        await deleteWorkflow(dbConfig, flow, existingId);
+        wasDeleted = true;
+        componentStats[type].deleted++;
       }
-      spinner.fail(chalk.red(`✗ ${fileName} → ${errorMsg}`));
-      failCount++;
+      
+      // Publish to API
+      const result = await publishComponent(apiConfig.baseUrl, metadata.data);
+      
+      if (result.success) {
+        const action = wasDeleted ? 'reset' : 'created';
+        LOG.component(type, fileName, 'success', `→ ${action}`);
+        componentStats[type].success++;
+      } else {
+        LOG.component(type, fileName, 'error', result.error);
+        componentStats[type].failed++;
+        errors.push({ type, file: fileName, error: result.error });
+      }
+    } 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('RESET SUMMARY');
+  
+  // Component statistics
+  console.log(chalk.white.bold('\n  Component Reset Results:\n'));
+  
+  for (const [type, stats] of Object.entries(componentStats)) {
+    const successLabel = stats.success > 0 ? chalk.green(`${stats.success} reset`) : '';
+    const deletedLabel = stats.deleted > 0 ? chalk.yellow(`${stats.deleted} deleted`) : '';
+    const failedLabel = stats.failed > 0 ? chalk.red(`${stats.failed} failed`) : '';
+    const skippedLabel = stats.skipped > 0 ? chalk.dim(`${stats.skipped} skipped`) : '';
+    
+    const parts = [successLabel, deletedLabel, failedLabel, skippedLabel].filter(Boolean);
+    console.log(`  ${chalk.cyan(type.padEnd(12))} : ${parts.join(', ') || chalk.dim('0')}`);
+  }
+  
+  // Errors
+  if (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}`));
+    }
   }
-  console.log(chalk.cyan('═'.repeat(50)));
-  console.log();
   
-  if (successCount > 0) {
-    console.log(chalk.green.bold('✓ Reset tamamlandı\n'));
+  LOG.separator();
+  
+  const totalFailed = Object.values(componentStats).reduce((sum, s) => sum + s.failed, 0);
+  
+  if (totalSuccess > 0 && totalFailed === 0) {
+    console.log(chalk.green.bold('\n  ✓ Reset completed\n'));
+  } else if (totalFailed > 0) {
+    console.log(chalk.yellow.bold(`\n  ⚠ Reset completed (${totalFailed} errors)\n`));
   }
 }
 
 module.exports = resetCommand;
-