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

package/src/lib/discover.js

@@ -1,65 +1,167 @@
 const { glob } = require('glob');
 const path = require('path');
 const fs = require('fs');
-
-const COMPONENTS = ['Workflows', 'Tasks', 'Schemas', 'Views', 'Functions', 'Extensions'];
+const { getComponentsRoot, getComponentTypes } = require('./vnextConfig');
 
 /**
- * Proje içinde component klasörlerini otomatik bulur
+ * Discovers component folders based on vnext.config.json paths
+ * Only scans folders defined in paths, ignores everything else
+ * @param {string} projectRoot - Project root folder (PROJECT_ROOT)
+ * @returns {Object} Discovered component folders
  */
 async function discoverComponents(projectRoot) {
+  const componentsRoot = getComponentsRoot(projectRoot);
+  const componentTypes = getComponentTypes(projectRoot);
+  
   const discovered = {};
   
-  for (const component of COMPONENTS) {
-    try {
-      // 3 seviye derinlikte ara
-      const pattern = path.join(projectRoot, '**', component);
-      const matches = await glob(pattern, {
-        maxDepth: 3,
-        ignore: ['**/node_modules/**', '**/dist/**', '**/.git/**']
-      });
+  // Only look for folders defined in paths
+  for (const [type, folderName] of Object.entries(componentTypes)) {
+    const componentDir = path.join(componentsRoot, folderName);
+    
+    if (fs.existsSync(componentDir) && fs.statSync(componentDir).isDirectory()) {
+      discovered[type] = componentDir;
+    }
+  }
+  
+  return discovered;
+}
+
+/**
+ * Finds all JSON files in a specific component folder
+ * Scans subfolders recursively
+ * Ignores .meta folders and *.diagram.json files
+ * @param {string} componentDir - Component folder
+ * @returns {Promise<string[]>} JSON file paths
+ */
+async function findJsonInComponent(componentDir) {
+  const pattern = path.join(componentDir, '**/*.json');
+  
+  const files = await glob(pattern, {
+    ignore: [
+      '**/.meta/**',
+      '**/.meta',
+      '**/*.diagram.json',
+      '**/package*.json',
+      '**/*config*.json'
+    ]
+  });
+  
+  return files;
+}
+
+/**
+ * Finds all JSON files in discovered components ONLY
+ * Does NOT scan folders outside of paths definition
+ * @param {Object} discovered - Discovered component folders
+ * @returns {Promise<Object[]>} JSON file info (path, type, fileName)
+ */
+async function findAllJsonFiles(discovered) {
+  const allFiles = [];
+  
+  // Only scan folders that were discovered from paths
+  for (const [type, componentDir] of Object.entries(discovered)) {
+    if (componentDir) {
+      const files = await findJsonInComponent(componentDir);
       
-      if (matches.length > 0) {
-        // İlk bulunanı al
-        const dir = matches[0];
-        if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
-          discovered[component] = dir;
-        }
+      for (const file of files) {
+        allFiles.push({
+          path: file,
+          type: type,
+          fileName: path.basename(file)
+        });
       }
-    } catch (error) {
-      // Ignore errors
     }
   }
   
-  return discovered;
+  return allFiles;
 }
 
 /**
- * Belirli bir component klasörünü getirir
+ * 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 findAllCsxInComponents(projectRoot) {
+  const discovered = await discoverComponents(projectRoot);
+  const allCsxFiles = [];
+  
+  // Only scan folders that were discovered from paths
+  for (const [type, componentDir] of Object.entries(discovered)) {
+    if (componentDir) {
+      const pattern = path.join(componentDir, '**/*.csx');
+      const files = await glob(pattern, {
+        ignore: [
+          '**/.meta/**',
+          '**/.meta',
+          '**/node_modules/**',
+          '**/dist/**'
+        ]
+      });
+      allCsxFiles.push(...files);
+    }
+  }
+  
+  return allCsxFiles;
+}
+
+/**
+ * Gets a specific component folder
+ * @param {Object} discovered - Discovered component folders
+ * @param {string} component - Component type
+ * @returns {string|null} Folder path
  */
 function getComponentDir(discovered, component) {
   return discovered[component] || null;
 }
 
 /**
- * Bulunan klasörleri listeler
+ * Lists discovered folders
+ * @param {Object} discovered - Discovered component folders
+ * @param {Object} componentTypes - All component types from paths
+ * @returns {Object[]} Folder list
  */
-function listDiscovered(discovered) {
+function listDiscovered(discovered, componentTypes) {
   const results = [];
-  for (const component of COMPONENTS) {
+  
+  for (const [type, folderName] of Object.entries(componentTypes)) {
     results.push({
-      name: component,
-      path: discovered[component] || null,
-      found: !!discovered[component]
+      name: type,
+      folderName: folderName,
+      path: discovered[type] || null,
+      found: !!discovered[type]
     });
   }
+  
   return results;
 }
 
+/**
+ * Detects component type from file path
+ * @param {string} filePath - File path
+ * @param {Object} componentTypes - Component type -> folder name mapping
+ * @returns {string} Component type
+ */
+function detectComponentTypeFromPath(filePath, componentTypes) {
+  const normalizedPath = filePath.toLowerCase();
+  
+  for (const [type, folderName] of Object.entries(componentTypes)) {
+    const folderPattern = `/${folderName.toLowerCase()}/`;
+    if (normalizedPath.includes(folderPattern)) {
+      return type;
+    }
+  }
+  
+  return 'unknown';
+}
+
 module.exports = {
   discoverComponents,
+  findJsonInComponent,
+  findAllJsonFiles,
+  findAllCsxInComponents,
   getComponentDir,
   listDiscovered,
-  COMPONENTS
+  detectComponentTypeFromPath
 };
-

package/src/lib/vnextConfig.js

@@ -0,0 +1,124 @@
+const fs = require('fs');
+const path = require('path');
+
+let cachedConfig = null;
+let cachedProjectRoot = null;
+
+/**
+ * Reads and parses vnext.config.json file
+ * @param {string} projectRoot - Project root folder
+ * @returns {Object} vnext.config.json content
+ */
+function loadVnextConfig(projectRoot) {
+  // Cache check
+  if (cachedConfig && cachedProjectRoot === projectRoot) {
+    return cachedConfig;
+  }
+
+  const configPath = path.join(projectRoot, 'vnext.config.json');
+  
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`vnext.config.json not found: ${configPath}`);
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    cachedConfig = JSON.parse(content);
+    cachedProjectRoot = projectRoot;
+    return cachedConfig;
+  } catch (error) {
+    throw new Error(`Failed to read vnext.config.json: ${error.message}`);
+  }
+}
+
+/**
+ * Returns domain information
+ * @param {string} projectRoot - Project root folder
+ * @returns {string} Domain name
+ */
+function getDomain(projectRoot) {
+  const config = loadVnextConfig(projectRoot);
+  
+  if (!config.domain) {
+    throw new Error('domain not found in vnext.config.json');
+  }
+  
+  return config.domain;
+}
+
+/**
+ * Returns paths information
+ * @param {string} projectRoot - Project root folder
+ * @returns {Object} Paths object
+ */
+function getPaths(projectRoot) {
+  const config = loadVnextConfig(projectRoot);
+  
+  if (!config.paths) {
+    throw new Error('paths not found in vnext.config.json');
+  }
+  
+  return config.paths;
+}
+
+/**
+ * Returns components root folder
+ * @param {string} projectRoot - Project root folder
+ * @returns {string} Components root folder path
+ */
+function getComponentsRoot(projectRoot) {
+  const paths = getPaths(projectRoot);
+  
+  if (!paths.componentsRoot) {
+    throw new Error('paths.componentsRoot not found in vnext.config.json');
+  }
+  
+  return path.join(projectRoot, paths.componentsRoot);
+}
+
+/**
+ * Returns component types and folder names
+ * @param {string} projectRoot - Project root folder
+ * @returns {Object} Component type -> folder name mapping
+ */
+function getComponentTypes(projectRoot) {
+  const paths = getPaths(projectRoot);
+  
+  // All paths except componentsRoot are component types
+  const componentTypes = {};
+  
+  for (const [key, value] of Object.entries(paths)) {
+    if (key !== 'componentsRoot') {
+      componentTypes[key] = value;
+    }
+  }
+  
+  return componentTypes;
+}
+
+/**
+ * Returns full configuration
+ * @param {string} projectRoot - Project root folder
+ * @returns {Object} Full vnext.config.json content
+ */
+function getFullConfig(projectRoot) {
+  return loadVnextConfig(projectRoot);
+}
+
+/**
+ * Clears the cache
+ */
+function clearCache() {
+  cachedConfig = null;
+  cachedProjectRoot = null;
+}
+
+module.exports = {
+  loadVnextConfig,
+  getDomain,
+  getPaths,
+  getComponentsRoot,
+  getComponentTypes,
+  getFullConfig,
+  clearCache
+};

package/src/lib/workflow.js

@@ -1,11 +1,15 @@
 const fs = require('fs').promises;
 const path = require('path');
 const { glob } = require('glob');
+const { publishComponent } = require('./api');
 const { getInstanceId, deleteWorkflow } = require('./db');
-const { postWorkflow, activateWorkflow, reinitializeSystem } = require('./api');
+const { getComponentTypes } = require('./vnextConfig');
+const { discoverComponents, findJsonInComponent } = require('./discover');
 
 /**
- * JSON dosyasından key ve version değerlerini alır
+ * Gets key and version values from JSON file
+ * @param {string} jsonPath - JSON file path
+ * @returns {Promise<Object>} Metadata object
  */
 async function getJsonMetadata(jsonPath) {
   const content = await fs.readFile(jsonPath, 'utf8');
@@ -20,11 +24,38 @@ async function getJsonMetadata(jsonPath) {
 }
 
 /**
- * Dosya yolundan flow tipini belirler
+ * Detects component type from file path based on vnext.config.json paths
+ * @param {string} jsonPath - JSON file path
+ * @param {string} projectRoot - Project root folder
+ * @returns {string} Component type (sys-flows, sys-tasks, etc.)
  */
-function detectFlowFromPath(jsonPath) {
+function detectComponentType(jsonPath, projectRoot) {
   const pathLower = jsonPath.toLowerCase();
   
+  try {
+    const componentTypes = getComponentTypes(projectRoot);
+    
+    // Check each component type folder
+    for (const [type, folderName] of Object.entries(componentTypes)) {
+      const folderPattern = `/${folderName.toLowerCase()}/`;
+      if (pathLower.includes(folderPattern)) {
+        // Map to flow type
+        switch (type.toLowerCase()) {
+          case 'workflows': return 'sys-flows';
+          case 'tasks': return 'sys-tasks';
+          case 'schemas': return 'sys-schemas';
+          case 'views': return 'sys-views';
+          case 'functions': return 'sys-functions';
+          case 'extensions': return 'sys-extensions';
+          default: return `sys-${type.toLowerCase()}`;
+        }
+      }
+    }
+  } catch (error) {
+    // Fallback to path-based detection
+  }
+  
+  // Fallback: detect from path directly
   if (pathLower.includes('/workflows/')) return 'sys-flows';
   if (pathLower.includes('/tasks/')) return 'sys-tasks';
   if (pathLower.includes('/schemas/')) return 'sys-schemas';
@@ -36,63 +67,67 @@ function detectFlowFromPath(jsonPath) {
 }
 
 /**
- * Tek bir workflow'u işler (DB'den sil, POST, Activate)
+ * Processes a single component (DB check → delete if exists → publish)
+ * @param {string} jsonPath - JSON file path
+ * @param {Object} dbConfig - Database configuration
+ * @param {string} baseUrl - API base URL
+ * @param {string} projectRoot - Project root folder
+ * @returns {Promise<Object>} Process result
  */
-async function processWorkflow(jsonPath, dbConfig, apiConfig) {
+async function processComponent(jsonPath, dbConfig, baseUrl, projectRoot) {
   const metadata = await getJsonMetadata(jsonPath);
   
   if (!metadata.key || !metadata.version) {
-    throw new Error('JSON\'da key veya version bulunamadı');
+    throw new Error('No key or version found in JSON');
   }
   
-  const flow = metadata.flow || detectFlowFromPath(jsonPath);
+  const componentType = detectComponentType(jsonPath, projectRoot);
+  const flow = metadata.flow || componentType;
   
-  // 1. DB'de var mı kontrol et
-  const instanceId = await getInstanceId(dbConfig, flow, metadata.key, metadata.version);
+  // 1. Check if exists in DB
+  const existingId = await getInstanceId(dbConfig, flow, metadata.key, metadata.version);
   
-  // 2. Varsa sil
-  if (instanceId) {
-    await deleteWorkflow(dbConfig, flow, instanceId);
+  // 2. If exists, delete first
+  let wasDeleted = false;
+  if (existingId) {
+    await deleteWorkflow(dbConfig, flow, existingId);
+    wasDeleted = true;
   }
   
-  // 3. API'ye POST et
-  const apiUrl = apiConfig.baseUrl;
-  const apiVersion = apiConfig.version;
-  
-  const postResult = await postWorkflow(apiUrl, apiVersion, flow, metadata.data);
-  const newInstanceId = postResult.id || postResult.Id;
+  // 3. Publish to API
+  const result = await publishComponent(baseUrl, metadata.data);
   
-  if (!newInstanceId) {
-    throw new Error('API POST başarılı ama instance ID alınamadı');
+  if (!result.success) {
+    throw new Error(result.error);
   }
   
-  // 4. Aktif et
-  await activateWorkflow(apiUrl, apiVersion, flow, newInstanceId, metadata.version);
-  
   return {
     key: metadata.key,
     version: metadata.version,
-    flow: flow,
-    instanceId: newInstanceId,
-    wasDeleted: !!instanceId
+    componentType: componentType,
+    wasDeleted: wasDeleted,
+    success: true
   };
 }
 
 /**
- * Git'te değişen JSON dosyalarını bulur
+ * Finds changed JSON files in Git
+ * Only returns files within PROJECT_ROOT
+ * @param {string} projectRoot - Project root folder
+ * @returns {Promise<string[]>} Changed JSON file paths
  */
 async function getGitChangedJson(projectRoot) {
   const { exec } = require('child_process');
   const util = require('util');
   const execPromise = util.promisify(exec);
-  const fs = require('fs');
+  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);
     
@@ -108,12 +143,13 @@ async function getGitChangedJson(projectRoot) {
         return path.normalize(fullPath);
       })
       .filter(file => {
-        // Workflow JSON'larını filtrele ve sadece project içindekileri al
+        // Filter workflow JSONs and only those in project
         const fileName = path.basename(file);
         return file.endsWith('.json') && 
                !fileName.includes('package') && 
                !fileName.includes('config') &&
-               fs.existsSync(file) &&
+               !fileName.includes('.diagram.') &&
+               fsSync.existsSync(file) &&
                file.startsWith(path.normalize(projectRoot));
       });
     
@@ -124,22 +160,34 @@ async function getGitChangedJson(projectRoot) {
 }
 
 /**
- * Belirli bir component klasöründeki tüm JSON dosyalarını bulur
+ * Finds all JSON files in a component folder
+ * @param {string} componentDir - Component folder
+ * @returns {Promise<string[]>} JSON file paths
  */
 async function findAllJsonInComponent(componentDir) {
   const pattern = path.join(componentDir, '**/*.json');
   const files = await glob(pattern, {
-    ignore: ['**/package*.json', '**/*config*.json', '**/*.diagram.json']
+    ignore: [
+      '**/.meta/**',
+      '**/.meta',
+      '**/*.diagram.json',
+      '**/package*.json',
+      '**/*config*.json'
+    ]
   });
   return files;
 }
 
 /**
- * Tüm component'lerdeki JSON dosyalarını bulur
+ * Finds all JSON files in discovered components ONLY
+ * Does NOT scan folders outside of paths definition
+ * @param {Object} discovered - Discovered component folders
+ * @returns {Promise<string[]>} JSON file paths
  */
 async function findAllJson(discovered) {
   const allJsons = [];
   
+  // Only scan folders that were discovered from paths
   for (const component in discovered) {
     const componentDir = discovered[component];
     if (componentDir) {
@@ -153,10 +201,9 @@ async function findAllJson(discovered) {
 
 module.exports = {
   getJsonMetadata,
-  detectFlowFromPath,
-  processWorkflow,
+  detectComponentType,
+  processComponent,
   getGitChangedJson,
   findAllJsonInComponent,
   findAllJson
 };
-