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

package/src/lib/config.js

@@ -1,29 +1,239 @@
 const Conf = require('conf');
-const path = require('path');
+
+// Default config values for a domain
+const DEFAULT_DOMAIN_CONFIG = {
+  AUTO_DISCOVER: true,
+  API_BASE_URL: 'http://localhost:4201',
+  API_VERSION: 'v1',
+  DB_HOST: 'localhost',
+  DB_PORT: 5432,
+  DB_NAME: 'vNext_WorkflowDb',
+  DB_USER: 'postgres',
+  DB_PASSWORD: 'postgres',
+  USE_DOCKER: false,
+  DOCKER_POSTGRES_CONTAINER: 'vnext-postgres',
+  DEBUG_MODE: false
+};
+
+const DOMAIN_CONFIG_KEYS = Object.keys(DEFAULT_DOMAIN_CONFIG);
 
 const config = new Conf({
-  projectName: 'vnext-workflow-cli',
-  defaults: {
+  projectName: 'vnext-workflow-cli'
+});
+
+/**
+ * Migrates old flat config to new domain-aware format.
+ * Old: { API_BASE_URL: "...", DB_NAME: "..." }
+ * New: { ACTIVE_DOMAIN: "default", DOMAINS: [{ DOMAIN_NAME: "default", ... }] }
+ */
+function migrateConfig() {
+  const store = config.store;
+
+  // Already in new format - skip
+  if (store.ACTIVE_DOMAIN !== undefined && Array.isArray(store.DOMAINS)) {
+    return;
+  }
+
+  // Collect existing values from old flat config
+  const existingValues = {};
+  for (const key of DOMAIN_CONFIG_KEYS) {
+    if (store[key] !== undefined) {
+      existingValues[key] = store[key];
+    }
+  }
+
+  // Create default domain: defaults + any existing overrides
+  const defaultDomain = {
+    DOMAIN_NAME: 'default',
+    ...DEFAULT_DOMAIN_CONFIG,
+    ...existingValues
+  };
+
+  // Clear old keys and set new format via conf API
+  for (const key of DOMAIN_CONFIG_KEYS) {
+    config.delete(key);
+  }
+  config.set('ACTIVE_DOMAIN', 'default');
+  config.set('DOMAINS', [defaultDomain]);
+}
+
+// Run migration on module load
+migrateConfig();
+
+/**
+ * Returns the active domain config object.
+ * @returns {Object} Active domain config
+ */
+function getActiveDomainConfig() {
+  const activeDomain = config.get('ACTIVE_DOMAIN');
+  const domains = config.get('DOMAINS') || [];
+  const domain = domains.find(d => d.DOMAIN_NAME === activeDomain);
+
+  if (!domain) {
+    throw new Error(`Active domain "${activeDomain}" not found in config.`);
+  }
+  return domain;
+}
+
+/**
+ * Gets a config value from the active domain.
+ * PROJECT_ROOT always returns process.cwd().
+ * @param {string} key - Config key
+ * @returns {any} Config value
+ */
+function get(key) {
+  if (key === 'PROJECT_ROOT') {
+    return process.cwd();
+  }
+  if (key === 'ACTIVE_DOMAIN') {
+    return config.get('ACTIVE_DOMAIN');
+  }
+  const domainConfig = getActiveDomainConfig();
+  return domainConfig[key];
+}
+
+/**
+ * Sets a config value on the active domain.
+ * PROJECT_ROOT cannot be set (always uses cwd).
+ * @param {string} key - Config key
+ * @param {any} value - Config value
+ */
+function set(key, value) {
+  const RESERVED_KEYS = {
+    PROJECT_ROOT: 'PROJECT_ROOT is always the current working directory and cannot be changed.',
+    DOMAIN_NAME: 'DOMAIN_NAME cannot be changed directly. Use "wf domain add/remove" instead.',
+    ACTIVE_DOMAIN: 'ACTIVE_DOMAIN cannot be changed directly. Use "wf domain use <name>" instead.'
+  };
+
+  if (RESERVED_KEYS[key]) {
+    throw new Error(RESERVED_KEYS[key]);
+  }
+
+  const activeDomainName = config.get('ACTIVE_DOMAIN');
+  const domains = config.get('DOMAINS') || [];
+  const idx = domains.findIndex(d => d.DOMAIN_NAME === activeDomainName);
+
+  if (idx === -1) {
+    throw new Error(`Active domain "${activeDomainName}" not found.`);
+  }
+
+  domains[idx][key] = value;
+  config.set('DOMAINS', domains);
+}
+
+/**
+ * Gets all config values from the active domain.
+ * @returns {Object} All config values including PROJECT_ROOT and ACTIVE_DOMAIN
+ */
+function getAll() {
+  const domainConfig = getActiveDomainConfig();
+  return {
     PROJECT_ROOT: process.cwd(),
-    AUTO_DISCOVER: true,
-    API_BASE_URL: 'http://localhost:4201',
-    API_VERSION: 'v1',
-    DB_HOST: 'localhost',
-    DB_PORT: 5432,
-    DB_NAME: 'vNext_WorkflowDb',
-    DB_USER: 'postgres',
-    DB_PASSWORD: 'postgres',
-    USE_DOCKER: false,
-    DOCKER_POSTGRES_CONTAINER: 'vnext-postgres',
-    DEBUG_MODE: false
+    ACTIVE_DOMAIN: config.get('ACTIVE_DOMAIN'),
+    ...domainConfig
+  };
+}
+
+/**
+ * Resets config to default state.
+ */
+function clear() {
+  config.clear();
+  config.set('ACTIVE_DOMAIN', 'default');
+  config.set('DOMAINS', [{
+    DOMAIN_NAME: 'default',
+    ...DEFAULT_DOMAIN_CONFIG
+  }]);
+}
+
+/**
+ * Adds a new domain. Missing values are inherited from the default domain.
+ * @param {string} name - Domain name
+ * @param {Object} options - Domain config overrides
+ * @returns {Object} Created domain config
+ */
+function addDomain(name, options) {
+  const domains = config.get('DOMAINS') || [];
+
+  if (domains.find(d => d.DOMAIN_NAME === name)) {
+    throw new Error(`Domain "${name}" already exists.`);
   }
-});
+
+  // Use default domain as base, fall back to DEFAULT_DOMAIN_CONFIG
+  const defaultDomain = domains.find(d => d.DOMAIN_NAME === 'default');
+  const base = defaultDomain
+    ? { ...defaultDomain }
+    : { ...DEFAULT_DOMAIN_CONFIG };
+  delete base.DOMAIN_NAME;
+
+  const newDomain = {
+    DOMAIN_NAME: name,
+    ...base,
+    ...options
+  };
+
+  domains.push(newDomain);
+  config.set('DOMAINS', domains);
+  return newDomain;
+}
+
+/**
+ * Switches the active domain.
+ * @param {string} name - Domain name to activate
+ */
+function useDomain(name) {
+  const domains = config.get('DOMAINS') || [];
+  if (!domains.find(d => d.DOMAIN_NAME === name)) {
+    throw new Error(`Domain "${name}" not found.`);
+  }
+  config.set('ACTIVE_DOMAIN', name);
+}
+
+/**
+ * Lists all domains with active domain info.
+ * @returns {Object} { activeDomain, domains }
+ */
+function listDomains() {
+  return {
+    activeDomain: config.get('ACTIVE_DOMAIN'),
+    domains: config.get('DOMAINS') || []
+  };
+}
+
+/**
+ * Removes a domain. Cannot remove the default domain.
+ * If the removed domain was active, switches to default.
+ * @param {string} name - Domain name to remove
+ */
+function removeDomain(name) {
+  if (name === 'default') {
+    throw new Error('Cannot remove the default domain.');
+  }
+
+  const domains = config.get('DOMAINS') || [];
+  const filtered = domains.filter(d => d.DOMAIN_NAME !== name);
+
+  if (filtered.length === domains.length) {
+    throw new Error(`Domain "${name}" not found.`);
+  }
+
+  config.set('DOMAINS', filtered);
+
+  if (config.get('ACTIVE_DOMAIN') === name) {
+    config.set('ACTIVE_DOMAIN', 'default');
+  }
+}
 
 module.exports = {
-  get: (key) => config.get(key),
-  set: (key, value) => config.set(key, value),
-  getAll: () => config.store,
-  clear: () => config.clear(),
-  path: config.path
+  get,
+  set,
+  getAll,
+  clear,
+  path: config.path,
+  addDomain,
+  useDomain,
+  listDomains,
+  removeDomain,
+  getActiveDomainConfig,
+  DEFAULT_DOMAIN_CONFIG
 };
-

package/src/lib/csx.js

@@ -1,9 +1,12 @@
 const fs = require('fs').promises;
 const path = require('path');
 const { glob } = require('glob');
+const { discoverComponents, findAllJsonFiles } = require('./discover');
 
 /**
- * CSX dosyasını Base64'e çevirir
+ * Encodes CSX file to Base64
+ * @param {string} csxPath - CSX file path
+ * @returns {Promise<string>} Base64 encoded content
  */
 async function encodeToBase64(csxPath) {
   const content = await fs.readFile(csxPath, 'utf8');
@@ -11,28 +14,32 @@ async function encodeToBase64(csxPath) {
 }
 
 /**
- * CSX dosyası için ilgili JSON dosyalarını bulur
+ * Finds JSON files that reference the CSX file
+ * Only searches in paths defined in vnext.config.json
+ * @param {string} csxPath - CSX file path
+ * @param {string} projectRoot - Project root folder
+ * @returns {Promise<string[]>} Matching JSON file paths
  */
 async function findJsonFilesForCsx(csxPath, projectRoot) {
   const csxBaseName = path.basename(csxPath);
   
-  // Tüm JSON dosyalarını bul
-  const pattern = path.join(projectRoot, '**', '*.json');
-  const jsonFiles = await glob(pattern, {
-    ignore: ['**/node_modules/**', '**/dist/**', '**/package*.json', '**/*config*.json']
-  });
+  // Get discovered components (only paths defined in vnext.config.json)
+  const discovered = await discoverComponents(projectRoot);
   
-  // CSX referansı olan JSON'ları filtrele
+  // Get all JSON files from discovered components only
+  const jsonFileInfos = await findAllJsonFiles(discovered);
+  
+  // Filter JSONs that reference the CSX
   const matchingJsons = [];
   
-  for (const jsonFile of jsonFiles) {
+  for (const jsonInfo of jsonFileInfos) {
     try {
-      const content = await fs.readFile(jsonFile, 'utf8');
+      const content = await fs.readFile(jsonInfo.path, 'utf8');
       if (content.includes(csxBaseName)) {
-        matchingJsons.push(jsonFile);
+        matchingJsons.push(jsonInfo.path);
       }
     } catch (error) {
-      // Ignore
+      // Skip unreadable files
     }
   }
   
@@ -40,11 +47,14 @@ async function findJsonFilesForCsx(csxPath, projectRoot) {
 }
 
 /**
- * CSX location path'ini hesaplar
+ * Calculates CSX location path
+ * @param {string} csxPath - CSX file path
+ * @param {string} projectRoot - Project root folder
+ * @returns {string} Location path
  */
-function getCsxLocation(csxPath) {
-  // ./src/Rules/MyRule.csx formatına çevir
-  const parts = csxPath.split('/');
+function getCsxLocation(csxPath, projectRoot) {
+  // Convert to ./src/Rules/MyRule.csx format
+  const parts = csxPath.split(path.sep);
   const srcIndex = parts.lastIndexOf('src');
   
   if (srcIndex !== -1) {
@@ -56,91 +66,154 @@ function getCsxLocation(csxPath) {
 }
 
 /**
- * JSON dosyasında CSX code'unu günceller
+ * Updates ALL CSX codes in a JSON file
+ * Updates all references with the same location
+ * Supports encoding types: NAT (native/plain text), B64 (Base64, default)
+ * @param {string} jsonPath - JSON file path
+ * @param {string} csxLocation - CSX location path
+ * @param {string} base64Code - Base64 encoded CSX content
+ * @param {string} nativeCode - Native (plain text) CSX content
+ * @returns {Promise<number>} Number of updated references
  */
-async function updateCodeInJson(jsonPath, csxLocation, base64Code) {
+async function updateCodeInJson(jsonPath, csxLocation, base64Code, nativeCode) {
   const content = await fs.readFile(jsonPath, 'utf8');
   const data = JSON.parse(content);
   
-  // Recursive olarak location'ı bul ve güncelle
+  let updateCount = 0;
+  
+  // Recursively find and update ALL location matches
   function updateRecursive(obj) {
-    if (typeof obj !== 'object' || obj === null) return false;
+    if (typeof obj !== 'object' || obj === null) return;
+    
+    // Skip if location is missing
+    if (!obj.location) {
+      // Continue scanning children
+      for (const key in obj) {
+        if (typeof obj[key] === 'object' && obj[key] !== null) {
+          updateRecursive(obj[key]);
+        }
+      }
+      return;
+    }
     
     if (obj.location === csxLocation && 'code' in obj) {
-      obj.code = base64Code;
-      return true;
+      // Check encoding type: NAT = Native (plain text), B64 or empty = Base64 (default)
+      const encoding = obj.encoding ? obj.encoding.toUpperCase() : 'B64';
+      
+      if (encoding === 'NAT') {
+        // Native encoding - write plain text content
+        obj.code = nativeCode;
+      } else {
+        // B64 or default - write Base64 encoded content
+        obj.code = base64Code;
+      }
+      updateCount++;
     }
     
+    // Scan all elements in array or object
     for (const key in obj) {
-      if (updateRecursive(obj[key])) {
-        return true;
+      if (typeof obj[key] === 'object' && obj[key] !== null) {
+        updateRecursive(obj[key]);
       }
     }
-    
-    return false;
   }
   
-  const updated = updateRecursive(data);
+  updateRecursive(data);
   
-  if (updated) {
+  if (updateCount > 0) {
     await fs.writeFile(jsonPath, JSON.stringify(data, null, 2), 'utf8');
-    return true;
   }
   
-  return false;
+  return updateCount;
 }
 
 /**
- * Tek bir CSX dosyasını işler
+ * Reads CSX file content as plain text (native)
+ * @param {string} csxPath - CSX file path
+ * @returns {Promise<string>} Plain text content
+ */
+async function readNativeContent(csxPath) {
+  return await fs.readFile(csxPath, 'utf8');
+}
+
+/**
+ * Processes a single CSX file
+ * Updates ALL referencing JSON files
+ * Supports both NAT (native) and B64 (Base64) encoding
+ * @param {string} csxPath - CSX file path
+ * @param {string} projectRoot - Project root folder
+ * @returns {Promise<Object>} Process result
  */
 async function processCsxFile(csxPath, projectRoot) {
-  // Base64'e çevir
-  const base64Code = await encodeToBase64(csxPath);
+  // Read native content
+  const nativeCode = await readNativeContent(csxPath);
   
-  // İlgili JSON'ları bul
+  // Convert to Base64
+  const base64Code = Buffer.from(nativeCode).toString('base64');
+  
+  // Find ALL related JSONs (only in paths defined in vnext.config.json)
   const jsonFiles = await findJsonFilesForCsx(csxPath, projectRoot);
   
   if (jsonFiles.length === 0) {
-    return { success: false, message: 'İlgili JSON bulunamadı' };
+    return { 
+      success: false, 
+      message: 'No related JSON found',
+      updatedJsonCount: 0,
+      totalUpdates: 0,
+      jsonFiles: []
+    };
   }
   
-  // CSX location'ı hesapla
-  const csxLocation = getCsxLocation(csxPath);
+  // Calculate CSX location
+  const csxLocation = getCsxLocation(csxPath, projectRoot);
+  
+  // Update each JSON
+  let updatedJsonCount = 0;
+  let totalUpdates = 0;
+  const updatedFiles = [];
   
-  // Her JSON'u güncelle
-  let updatedCount = 0;
   for (const jsonFile of jsonFiles) {
     try {
-      const updated = await updateCodeInJson(jsonFile, csxLocation, base64Code);
-      if (updated) {
-        updatedCount++;
+      const updates = await updateCodeInJson(jsonFile, csxLocation, base64Code, nativeCode);
+      if (updates > 0) {
+        updatedJsonCount++;
+        totalUpdates += updates;
+        updatedFiles.push({
+          file: path.basename(jsonFile),
+          updates: updates
+        });
       }
     } catch (error) {
-      // Continue with next file
+      // Continue with next file on error
     }
   }
   
   return {
-    success: updatedCount > 0,
-    updatedCount,
-    jsonFiles: jsonFiles.map(f => path.basename(f))
+    success: updatedJsonCount > 0,
+    message: updatedJsonCount > 0 ? 'Updated' : 'No references to update',
+    updatedJsonCount,
+    totalUpdates,
+    jsonFiles: updatedFiles
   };
 }
 
 /**
- * Git'te değişen CSX dosyalarını bulur
+ * Finds changed CSX files in Git
+ * @param {string} projectRoot - Project root folder
+ * @returns {Promise<string[]>} Changed CSX file paths
  */
 async function getGitChangedCsx(projectRoot) {
   const { exec } = require('child_process');
   const util = require('util');
   const execPromise = util.promisify(exec);
+  const fsSync = require('fs');
   
   try {
-    // Git root'u bul
+    // Find git root
     const { stdout: gitRoot } = await execPromise('git rev-parse --show-toplevel', { cwd: projectRoot });
     const gitRootDir = gitRoot.trim();
     
-    // Git status'u git root'tan çalıştır
+    // Run git status from git root
     const { stdout } = await execPromise('git status --porcelain', { cwd: gitRootDir });
     const lines = stdout.split('\n').filter(Boolean);
     
@@ -158,7 +231,7 @@ async function getGitChangedCsx(projectRoot) {
       .filter(file => {
         // Only .csx files that exist and are in our project
         return file.endsWith('.csx') && 
-               require('fs').existsSync(file) &&
+               fsSync.existsSync(file) &&
                file.startsWith(path.normalize(projectRoot));
       });
     
@@ -169,18 +242,19 @@ async function getGitChangedCsx(projectRoot) {
 }
 
 /**
- * Tüm CSX dosyalarını bulur
+ * Finds all CSX files in discovered components ONLY
+ * Does NOT scan folders outside of paths definition
+ * @param {string} projectRoot - Project root folder
+ * @returns {Promise<string[]>} CSX file paths
  */
 async function findAllCsx(projectRoot) {
-  const pattern = path.join(projectRoot, '**', 'src', '**', '*.csx');
-  const files = await glob(pattern, {
-    ignore: ['**/node_modules/**', '**/dist/**']
-  });
-  return files;
+  const { findAllCsxInComponents } = require('./discover');
+  return findAllCsxInComponents(projectRoot);
 }
 
 module.exports = {
   encodeToBase64,
+  readNativeContent,
   findJsonFilesForCsx,
   getCsxLocation,
   updateCodeInJson,
@@ -188,4 +262,3 @@ module.exports = {
   getGitChangedCsx,
   findAllCsx
 };
-

package/src/lib/db.js

@@ -5,11 +5,11 @@ const util = require('util');
 const execPromise = util.promisify(exec);
 
 /**
- * DB bağlantısını test eder
+ * Tests the DB connection
  */
 async function testDbConnection(dbConfig) {
   if (dbConfig.useDocker) {
-    // Docker üzerinden test
+    // Test via Docker
     try {
       const cmd = `docker exec ${dbConfig.dockerContainer} psql -U ${dbConfig.user} -d ${dbConfig.database} -c "SELECT 1;"`;
       await execPromise(cmd);
@@ -18,7 +18,7 @@ async function testDbConnection(dbConfig) {
       return false;
     }
   } else {
-    // Direkt bağlantı
+    // Direct connection
     const client = new Client({
       host: dbConfig.host,
       port: dbConfig.port,
@@ -39,15 +39,15 @@ async function testDbConnection(dbConfig) {
 }
 
 /**
- * Workflow'un DB'deki ID'sini bulur
- * NOT: Version kontrolü yapmıyoruz, sadece Key'e bakıyoruz (bash script gibi)
+ * Finds the workflow's ID in the DB
+ * NOTE: We don't check version, only the Key (like the bash script)
  */
 async function getInstanceId(dbConfig, schema, key, version) {
   const dbSchema = schema.replace(/-/g, '_');
   const query = `SELECT "Id" FROM "${dbSchema}"."Instances" WHERE "Key" = $1 ORDER BY "CreatedAt" DESC LIMIT 1`;
   
   if (dbConfig.useDocker) {
-    // Docker üzerinden - SQL içindeki double quote'ları backslash ile escape et
+    // Via Docker - escape double quotes in SQL with backslash
     const cmd = `docker exec ${dbConfig.dockerContainer} psql -U ${dbConfig.user} -d ${dbConfig.database} -t -c "SELECT \\"Id\\" FROM \\"${dbSchema}\\".\\"Instances\\" WHERE \\"Key\\" = '${key}' ORDER BY \\"CreatedAt\\" DESC LIMIT 1"`;
     try {
       const { stdout } = await execPromise(cmd);
@@ -57,7 +57,7 @@ async function getInstanceId(dbConfig, schema, key, version) {
       return null;
     }
   } else {
-    // Direkt bağlantı
+    // Direct connection
     const client = new Client({
       host: dbConfig.host,
       port: dbConfig.port,
@@ -78,13 +78,13 @@ async function getInstanceId(dbConfig, schema, key, version) {
 }
 
 /**
- * Workflow'u DB'den siler
+ * Deletes a workflow from the DB
  */
 async function deleteWorkflow(dbConfig, schema, instanceId) {
   const dbSchema = schema.replace(/-/g, '_');
   
   if (dbConfig.useDocker) {
-    // Docker üzerinden - Double quote'ları escape et
+    // Via Docker - escape double quotes
     const cmd = `docker exec ${dbConfig.dockerContainer} psql -U ${dbConfig.user} -d ${dbConfig.database} -c "DELETE FROM \\"${dbSchema}\\".\\"Instances\\" WHERE \\"Id\\" = '${instanceId}'"`;
     try {
       await execPromise(cmd);
@@ -93,7 +93,7 @@ async function deleteWorkflow(dbConfig, schema, instanceId) {
       return false;
     }
   } else {
-    // Direkt bağlantı
+    // Direct connection
     const query = `DELETE FROM "${dbSchema}"."Instances" WHERE "Id" = $1`;
     const client = new Client({
       host: dbConfig.host,