testbeats 2.2.9 → 2.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testbeats",
-  "version": "2.2.9",
+  "version": "2.3.1",
   "description": "Publish test results to Microsoft Teams, Google Chat, Slack and InfluxDB",
   "main": "src/index.js",
   "types": "./src/index.d.ts",

package/src/beats/beats.api.js

@@ -9,6 +9,15 @@ class BeatsApi {
     this.config = config;
   }
 
+  searchProjects(search_text) {
+    return request.get({
+      url: `${this.getBaseUrl()}/api/core/v1/projects?search_text=${search_text}`,
+      headers: {
+        'x-api-key': this.config.api_key
+      }
+    });
+  }
+
   postTestRun(payload) {
     return request.post({
       url: `${this.getBaseUrl()}/api/core/v1/test-runs`,
@@ -75,6 +84,40 @@ class BeatsApi {
       }
     });
   }
+
+  /**
+   * @param {import('../types').IManualSyncComparePayload} payload
+   * @returns {Promise<import('../types').IManualSyncCompareResponse>}
+   */
+  compareManualTests(payload) {
+    return request.post({
+      url: `${this.getBaseUrl()}/api/core/v1/manual/sync/compare`,
+      headers: {
+        'x-api-key': this.config.api_key
+      },
+      body: payload
+    });
+  }
+
+  syncManualFolders(payload) {
+    return request.post({
+      url: `${this.getBaseUrl()}/api/core/v1/manual/sync/folders`,
+      headers: {
+        'x-api-key': this.config.api_key
+      },
+      body: payload
+    });
+  }
+
+  syncManualTestSuites(payload) {
+    return request.post({
+      url: `${this.getBaseUrl()}/api/core/v1/manual/sync/suites`,
+      headers: {
+        'x-api-key': this.config.api_key
+      },
+      body: payload
+    });
+  }
 }
 
 module.exports = { BeatsApi }

package/src/cli.js

@@ -68,6 +68,9 @@ prog.command('init')
 prog.command('manual sync')
   .describe('Sync manual test cases from gherkin files in a directory')
   .option('-p, --path', 'Path to directory to sync (default: current directory)')
+  .option('-c, --config', 'path to config file')
+  .option('--api-key', 'api key')
+  .option('--project', 'project name')
   .example('manual sync')
   .example('manual sync --path ./tests/features')
   .action(async (opts) => {

package/src/commands/base.command.js

@@ -0,0 +1,47 @@
+const pkg = require('../../package.json');
+const { MIN_NODE_VERSION } = require('../helpers/constants');
+const { ConfigBuilder } = require('../utils/config.builder');
+const logger = require('../utils/logger');
+const os = require('os');
+
+class BaseCommand {
+  constructor(opts) {
+    this.opts = opts;
+  }
+
+  printBanner() {
+    const banner = `
+     _____             _    ___                  _
+    (_   _)           ( )_ (  _'\\               ( )_
+      | |   __    ___ | ,_)| (_) )   __     _ _ | ,_)  ___
+      | | /'__'\\/',__)| |  |  _ <' /'__'\\ /'_' )| |  /',__)
+      | |(  ___/\\__, \\| |_ | (_) )(  ___/( (_| || |_ \\__, \\
+      (_)'\\____)(____/'\\__)(____/''\\____)'\\__,_)'\\__)(____/
+
+                         v${pkg.version}
+    `;
+    console.log(banner);
+  }
+
+  validateEnvDetails() {
+    try {
+      const current_major_version = parseInt(process.version.split('.')[0].replace('v', ''));
+      if (current_major_version >= MIN_NODE_VERSION) {
+        logger.info(`💻 NodeJS: ${process.version}, OS: ${os.platform()}, Version: ${os.release()}, Arch: ${os.machine()}`);
+        return;
+      }
+    } catch (error) {
+      logger.warn(`⚠️ Unable to verify NodeJS version: ${error.message}`);
+      return;
+    }
+    throw new Error(`❌ Supported NodeJS version is >= v${MIN_NODE_VERSION}. Current version is ${process.version}`)
+  }
+
+  buildConfig() {
+    const config_builder = new ConfigBuilder(this.opts);
+    config_builder.build();
+  }
+
+}
+
+module.exports = { BaseCommand };

package/src/commands/manual-sync.command.js

@@ -1,13 +1,14 @@
-const path = require('path');
 const { ManualSyncHelper } = require('../manual/sync.helper');
 const logger = require('../utils/logger');
+const { BeatsApi } = require('../beats/beats.api');
+const { BaseCommand } = require('./base.command');
 
-class ManualSyncCommand {
+class ManualSyncCommand extends BaseCommand {
   /**
    * @param {Object} opts - Command options
    */
   constructor(opts) {
-    this.opts = opts;
+    super(opts);
     this.syncHelper = new ManualSyncHelper();
   }
 
@@ -16,6 +17,10 @@ class ManualSyncCommand {
    */
   async execute() {
     try {
+      this.printBanner();
+      this.validateEnvDetails();
+      this.buildConfig();
+
       logger.info('🔄 Starting manual test case sync...');
 
       const targetPath = this.opts.path || '.';
@@ -23,17 +28,29 @@ class ManualSyncCommand {
 
       const result = await this.syncHelper.scanDirectory(targetPath);
 
+      const counts = this.getCounts(result);
+      logger.info(`📊 Found ${counts.totalTestCases} test cases, ${counts.totalTestSuites} test suites, and ${counts.totalFolders} folders`);
+
       // Format output as specified in requirements
       const output = {
-        folders: [result]
+        folders: result.folders
       };
 
-      // Display results
-      this.displayResults(output);
 
-      logger.info('✅ Manual sync completed successfully!');
 
-      return output;
+      const beats = new BeatsApi(this.opts.config);
+      const projectsResponse = await beats.searchProjects(this.opts.config.project);
+      const project = projectsResponse.values.find(p => p.name === this.opts.config.project);
+      if (!project) {
+        throw new Error(`Project ${this.opts.config.project} not found`);
+      }
+      this.opts.config.project = project.id;
+
+      const compare = new ManualSyncCompare(this.opts.config);
+      const compareResult = await compare.compare(output);
+
+      const resources = new ManualSyncResources(this.opts.config);
+      await resources.sync(output, compareResult);
 
     } catch (error) {
       logger.error(`❌ Manual sync failed: ${error.message}`);
@@ -41,39 +58,254 @@ class ManualSyncCommand {
     }
   }
 
+  getCounts(result, counts = { totalTestCases: 0, totalTestSuites: 0, totalFolders: 0 }) {
+    // return the total number of test cases, test suites, and folders
+    for (const folder of result.folders) {
+      counts.totalTestCases += folder.test_suites.reduce((acc, suite) => acc + suite.test_cases.length, 0);
+      counts.totalTestSuites += folder.test_suites.length;
+      counts.totalFolders += folder.folders.length;
+      this.getCounts(folder, counts);
+    }
+    return counts;
+  }
+}
+
+class ManualSyncCompare {
+
+  constructor(config) {
+    this.config = config;
+    this.beats = new BeatsApi(this.config);
+  }
+
+  /**
+   * @param {import('../types').IManualTestFolder} structure
+   */
+  async compare(structure) {
+    const payload = this.#buildPayload(structure);
+    const response = await this.beats.compareManualTests(payload);
+    return response;
+  }
+
+
+  /**
+   * Build the payload for the compare manual tests API
+   * @param {import('../types').IManualTestFolder} structure
+   * @returns {import('../types').IManualSyncComparePayload}
+   */
+  #buildPayload(structure) {
+    const payload = {
+      project_id: this.config.project,
+      folders: [],
+    };
+    for (const folder of structure.folders) {
+      payload.folders.push(this.#buildPayloadFolder(folder));
+    }
+    return payload;
+  }
+
+  /**
+   * Build the payload for a folder
+   * @param {import('../types').IManualTestFolder} folder
+   * @returns {import('../types').IManualSyncCompareFolder}
+   */
+  #buildPayloadFolder(folder) {
+    return {
+      name: folder.name,
+      hash: folder.hash,
+      test_suites: folder.test_suites.map(testSuite => this.#buildPayloadTestSuite(testSuite)),
+      folders: folder.folders.map(subFolder => this.#buildPayloadFolder(subFolder))
+    };
+  }
+
+  /**
+   * Build the payload for a test suite
+   * @param {import('../types').IManualTestSuite} testSuite
+   * @returns {import('../types').IManualSyncCompareTestSuite}
+   */
+  #buildPayloadTestSuite(testSuite) {
+    return {
+      name: testSuite.name,
+      hash: testSuite.hash,
+    };
+  }
+}
+
+class ManualSyncResources {
+  constructor(config) {
+    this.config = config;
+    this.beats = new BeatsApi(this.config);
+  }
+
+  /**
+   * Sync the manual resources
+   * @param {import('../types').IManualTestFolder} structure
+   * @param {import('../types').IManualSyncCompareResponse} compareResult
+   */
+  async sync(structure, compareResult) {
+    this.#mergeStructure(structure, compareResult);
+    await this.#syncFolders(structure.folders);
+  }
+
+  /**
+   * Merge the structure with the compare result
+   * @param {import('../types').IManualTestFolder} structure
+   * @param {import('../types').IManualSyncCompareResponse} compareResult
+   */
+  #mergeStructure(structure, compareResult) {
+    // Iterate through all folders from compare result and merge with local structure
+    for (const serverFolder of compareResult.folders) {
+      const localFolder = structure.folders.find(f => f.name === serverFolder.name);
+      if (localFolder) {
+        this.#mergeFolder(localFolder, serverFolder);
+      } else {
+        structure.folders.push(this.#convertServerFolderToLocal(serverFolder));
+      }
+    }
+  }
+
+  /**
+   * Merge server folder metadata into local folder
+   * @param {import('../types').IManualTestFolder} localFolder - Local folder with full data
+   * @param {import('../types').IManualSyncCompareResponseFolder} serverFolder - Server folder with metadata
+   */
+  #mergeFolder(localFolder, serverFolder) {
+    // Enrich local folder with server metadata
+    localFolder.id = serverFolder.id;
+    localFolder.type = serverFolder.type;
+
+    // Ensure server folder has test suites and folders
+    serverFolder.test_suites = serverFolder.test_suites || [];
+    serverFolder.folders = serverFolder.folders || [];
+
+    for (const serverSuite of serverFolder.test_suites) {
+      const localSuite = localFolder.test_suites.find(s => s.name === serverSuite.name);
+      if (localSuite) {
+        this.#mergeTestSuite(localSuite, serverSuite);
+      } else {
+        localFolder.test_suites.push(this.#convertServerSuiteToLocal(serverSuite));
+      }
+    }
+
+    for (const serverSubFolder of serverFolder.folders) {
+      const localSubFolder = localFolder.folders.find(f => f.name === serverSubFolder.name);
+      if (localSubFolder) {
+        this.#mergeFolder(localSubFolder, serverSubFolder);
+      } else {
+        localFolder.folders.push(this.#convertServerFolderToLocal(serverSubFolder));
+      }
+    }
+  }
+
   /**
-   * Display sync results in a readable format
-   * @param {Object} output - Sync results
+   * Merge server test suite metadata into local test suite
+   * @param {import('../types').IManualTestSuite} localSuite - Local test suite with full data
+   * @param {import('../types').IManualSyncCompareResponseTestSuite} serverSuite - Server suite with metadata
    */
-  displayResults(output) {
-    logger.info('\n📊 Sync Results:');
-    this.displayFolderRecursive(output.folders[0], 0);
+  #mergeTestSuite(localSuite, serverSuite) {
+    localSuite.id = serverSuite.id;
+    localSuite.type = serverSuite.type;
   }
 
   /**
-   * Recursively display folder structure
-   * @param {Object} folder - Folder object
-   * @param {number} depth - Current depth for indentation
+   * Convert server folder to local folder structure (for delete operations)
+   * @param {import('../types').IManualSyncCompareResponseFolder} serverFolder - Server folder
+   * @returns {import('../types').IManualTestFolder} Local folder structure
    */
-  displayFolderRecursive(folder, depth) {
-    const indent = '  '.repeat(depth);
+  #convertServerFolderToLocal(serverFolder) {
+    return {
+      name: serverFolder.name,
+      path: '',
+      hash: serverFolder.hash,
+      id: serverFolder.id,
+      type: serverFolder.type,
+      test_suites: serverFolder.test_suites?.map(s => this.#convertServerSuiteToLocal(s)) || [],
+      folders: serverFolder.folders?.map(f => this.#convertServerFolderToLocal(f)) || []
+    };
+  }
 
-    logger.info(`${indent}📁 ${folder.name} (${folder.path})`);
+  /**
+   * Convert server test suite to local test suite structure (for delete operations)
+   * @param {import('../types').IManualSyncCompareResponseTestSuite} serverSuite - Server suite
+   * @returns {import('../types').IManualTestSuite} Local test suite structure
+   */
+  #convertServerSuiteToLocal(serverSuite) {
+    return {
+      name: serverSuite.name,
+      tags: [],
+      before_each: [],
+      test_cases: [],
+      hash: serverSuite.hash,
+      id: serverSuite.id,
+      type: serverSuite.type
+    };
+  }
 
-    if (folder.test_suites.length > 0) {
-      logger.info(`${indent}  📋 Test Suites: ${folder.test_suites.length}`);
-      folder.test_suites.forEach(suite => {
-        logger.info(`${indent}    • ${suite.name} (${suite.test_cases.length} test cases)`);
-      });
+  async #syncFolders(folders) {
+    const payload = {
+      project_id: this.config.project,
+      folders: folders.map(folder => ({
+        type: folder.type,
+        id: folder.id,
+        name: folder.name,
+        hash: folder.hash,
+        parent_folder_id: folder.parent_folder_id,
+      })),
+    };
+    const response = await this.beats.syncManualFolders(payload);
+    const results = response.results;
+    for (const result of results) {
+      if (result.success) {
+        logger.info(`✅ Folder '${result.name}' synced successfully`);
+        const folder = folders.find(f => f.name === result.name);
+        if (!folder) {
+          console.log(`❌ Folder ${result.name} not found in local structure`);
+          continue;
+        }
+        folder.id = folder.id || result.id;
+        for (const testSuite of folder.test_suites) {
+          testSuite.folder_id = folder.id;
+        }
+        await this.#syncTestSuites(folder.test_suites);
+        for (const subFolder of folder.folders) {
+          subFolder.parent_folder_id = folder.id;
+        }
+        await this.#syncFolders(folder.folders);
+      }
     }
+  }
 
-    if (folder.folders.length > 0) {
-      logger.info(`${indent}  📂 Subfolders: ${folder.folders.length}`);
-      folder.folders.forEach(subFolder => {
-        this.displayFolderRecursive(subFolder, depth + 1);
-      });
+  async #syncTestSuites(testSuites) {
+    const payload = {
+      project_id: this.config.project,
+      suites: testSuites.map(testSuite => ({
+        type: testSuite.type,
+        name: testSuite.name,
+        folder_id: testSuite.folder_id,
+        hash: testSuite.hash,
+        tags: testSuite.tags,
+        before_each: testSuite.before_each.map(step => step.name),
+        test_cases: testSuite.test_cases.map(tc => {
+          return {
+            name: tc.name,
+            type: tc.type,
+            tags: tc.tags,
+            steps: tc.steps.map(step => step.name),
+            hash: tc.hash,
+          };
+        }),
+      })),
+    };
+    const response = await this.beats.syncManualTestSuites(payload);
+    const results = response.results;
+    for (const result of results) {
+      if (result.success) {
+        logger.info(`✅ Test Suite '${result.name}' synced successfully`);
+      } else {
+        logger.error(`❌ Test Suite '${result.name}' failed to sync: ${result.error}`);
+      }
     }
   }
+
 }
 
-module.exports = { ManualSyncCommand };
+module.exports = { ManualSyncCommand, ManualSyncCompare };

package/src/commands/publish.command.js

@@ -1,33 +1,29 @@
 const path = require('path');
 const trp = require('test-results-parser');
 const prp = require('performance-results-parser');
-const os = require('os');
 
 const beats = require('../beats');
-const { ConfigBuilder } = require('../utils/config.builder');
 const target_manager = require('../targets');
 const logger = require('../utils/logger');
 const { processData } = require('../helpers/helper');
 const { ExtensionsSetup } = require('../setups/extensions.setup');
-const pkg = require('../../package.json');
-const { MIN_NODE_VERSION } = require('../helpers/constants');
 const { sortExtensionsByOrder } = require('../helpers/extension.helper');
+const { BaseCommand } = require('./base.command');
 
-class PublishCommand {
+class PublishCommand extends BaseCommand {
 
   /**
    * @param {import('../index').CommandLineOptions} opts
    */
   constructor(opts) {
-    this.opts = opts;
+    super(opts);
     this.errors = [];
   }
 
   async publish() {
-    logger.info(`🥁 TestBeats v${pkg.version}`);
-
-    this.#validateEnvDetails();
-    this.#buildConfig();
+    this.printBanner();
+    this.validateEnvDetails();
+    this.buildConfig();
     this.#validateOptions();
     this.#setConfigFromFile();
     this.#mergeConfigOptions();
@@ -39,25 +35,6 @@ class PublishCommand {
     await this.#publishErrors();
   }
 
-  #validateEnvDetails() {
-    try {
-      const current_major_version = parseInt(process.version.split('.')[0].replace('v', ''));
-      if (current_major_version >= MIN_NODE_VERSION) {
-        logger.info(`💻 NodeJS: ${process.version}, OS: ${os.platform()}, Version: ${os.release()}, Arch: ${os.machine()}`);
-        return;
-      }
-    } catch (error) {
-      logger.warn(`⚠️ Unable to verify NodeJS version: ${error.message}`);
-      return;
-    }
-    throw new Error(`❌ Supported NodeJS version is >= v${MIN_NODE_VERSION}. Current version is ${process.version}`)
-  }
-
-  #buildConfig() {
-    const config_builder = new ConfigBuilder(this.opts);
-    config_builder.build();
-  }
-
   #validateOptions() {
     if (!this.opts) {
       throw new Error('Missing publish options');

package/src/manual/parsers/base.js

@@ -0,0 +1,39 @@
+const hash = require('object-hash');
+
+class BaseParser {
+  hash(obj) {
+    return hash(obj, { algorithm: 'md5' });
+  }
+
+  /**
+   * Hash a test case
+   * @param {import('../../types').IManualTestCase} testCase
+   * @returns {string}
+   */
+  hashTestCase(testCase) {
+    return this.hash({
+      name: testCase.name,
+      type: testCase.type,
+      tags: testCase.tags,
+      steps: testCase.steps,
+      path: testCase.path
+    });
+  }
+
+  /**
+   * Hash a test suite
+   * @param {import('../../types').IManualTestSuite} testSuite
+   * @returns {string}
+   */
+  hashTestSuite(testSuite) {
+    return this.hash({
+      name: testSuite.name,
+      type: testSuite.type,
+      tags: testSuite.tags,
+      before_each: testSuite.before_each,
+      test_cases: testSuite.test_cases.map(testCase => testCase.hash)
+    });
+  }
+}
+
+module.exports = { BaseParser };

package/src/manual/parsers/gherkin.js

@@ -1,11 +1,13 @@
 const fs = require('fs');
+const { BaseParser } = require('./base');
 
 /**
  * Simple and extendable Gherkin parser for Cucumber feature files
  * Parses .feature files and returns structured test suite objects
  */
-class GherkinParser {
+class GherkinParser extends BaseParser {
   constructor() {
+    super();
     /** @type {string[]} Supported step keywords */
     this.stepKeywords = ['Given', 'When', 'Then', 'And', 'But'];
   }
@@ -31,12 +33,15 @@ class GherkinParser {
    * @returns {Object}
    */
   parseLines(lines) {
+    /**
+     * @type {import('../../types').IManualTestSuite}
+     */
     const testSuite = {
       name: '',
       type: 'feature',
       tags: [],
-      beforeEach: [],
-      cases: []
+      before_each: [],
+      test_cases: []
     };
 
     let currentFeature = null;
@@ -71,12 +76,12 @@ class GherkinParser {
       } else if (line.startsWith('Background:')) {
         // Parse Background
         currentBackground = this.parseBackground();
-        testSuite.beforeEach.push(currentBackground);
+        testSuite.before_each.push(currentBackground);
       } else if (line.startsWith('Scenario:')) {
         // Parse Scenario
         currentScenario = this.parseScenario(line);
         currentScenario.tags = pendingScenarioTags.map(tag => tag.name);
-        testSuite.cases.push(currentScenario);
+        testSuite.test_cases.push(currentScenario);
         pendingScenarioTags = [];
         currentBackground = null; // Reset Background context when Scenario starts
       } else if (this.isStep(line)) {
@@ -94,6 +99,11 @@ class GherkinParser {
       }
     }
 
+    for (const testCase of testSuite.test_cases) {
+      testCase.hash = this.hashTestCase(testCase);
+    }
+    testSuite.hash = this.hashTestSuite(testSuite);
+
     return testSuite;
   }
 
@@ -169,7 +179,7 @@ class GherkinParser {
   /**
    * Parse Scenario line
    * @param {string} line
-   * @returns {Object}
+   * @returns {import('../../types').IManualTestCase}
    */
   parseScenario(line) {
     const name = line.replace('Scenario:', '').trim();
@@ -229,8 +239,8 @@ class GherkinParser {
            document.name &&
            document.type === 'feature' &&
            Array.isArray(document.tags) &&
-           Array.isArray(document.beforeEach) &&
-           Array.isArray(document.cases);
+           Array.isArray(document.before_each) &&
+           Array.isArray(document.test_cases);
   }
 }
 

package/src/manual/sync.helper.js

@@ -56,6 +56,35 @@ class ManualSyncHelper {
     };
   }
 
+  /**
+   * Hash a folder
+   * @param {import('../types').IManualTestFolder} folder
+   * @returns {string} Hash string
+   */
+  hashFolder(folder) {
+    return this.generateHash({
+      name: folder.name,
+      path: folder.path,
+      test_suites: folder.test_suites.map(testSuite => testSuite.hash),
+      folders: folder.folders.map(subFolder => subFolder.hash)
+    });
+  }
+
+  /**
+   * Hash a test suite
+   * @param {import('../types').IManualTestSuite} testSuite
+   * @returns {string} Hash string
+   */
+  hashTestSuite(testSuite) {
+    return this.generateHash({
+      name: testSuite.name,
+      tags: testSuite.tags,
+      before_each: testSuite.before_each,
+      test_cases: testSuite.test_cases.map(testCase => testCase.hash)
+    });
+  }
+
+
   /**
    * Scan directory recursively and build folder structure
    * @param {string} directoryPath - Path to scan
@@ -72,20 +101,22 @@ class ManualSyncHelper {
       throw new Error(`Path is not a directory: ${directoryPath}`);
     }
 
-    const structure = this.buildFolderStructure(absolutePath, directoryPath);
-    return this.addFolderHash(structure);
+    return this.buildFolderStructure(absolutePath, directoryPath);
   }
 
   /**
    * Build folder structure recursively
    * @param {string} absolutePath - Absolute path for file operations
    * @param {string} relativePath - Relative path for output
-   * @returns {Object} Folder structure
+   * @returns {import('../types').IManualTestFolder} Folder structure
    */
   buildFolderStructure(absolutePath, relativePath) {
     const folderName = path.basename(absolutePath);
     const items = fs.readdirSync(absolutePath);
 
+    /**
+     * @type {import('../types').IManualTestFolder}
+     */
     const structure = {
       name: folderName,
       path: relativePath,
@@ -106,12 +137,26 @@ class ManualSyncHelper {
         // Parse gherkin files
         try {
           const testSuite = this.parseGherkinFile(itemPath, itemRelativePath);
+          testSuite.hash = this.hashTestSuite(testSuite);
           structure.test_suites.push(testSuite);
         } catch (error) {
           console.warn(`Warning: Failed to parse ${itemPath}: ${error.message}`);
         }
       }
     }
+    structure.hash = this.hashFolder(structure);
+    if (structure.test_suites.length > 0) {
+      const defaultFolder = {
+        name: 'default',
+        path: 'default',
+        hash: '',
+        test_suites: structure.test_suites,
+        folders: []
+      };
+      defaultFolder.hash = this.hashFolder(defaultFolder);
+      structure.folders.push(defaultFolder);
+      structure.test_suites = [];
+    }
 
     return structure;
   }
@@ -129,7 +174,7 @@ class ManualSyncHelper {
    * Parse a gherkin file and format output
    * @param {string} filePath - Path to gherkin file
    * @param {string} relativePath - Relative path for output
-   * @returns {Object} Formatted test suite
+   * @returns {import('../types').IManualTestSuite} Formatted test suite
    */
   parseGherkinFile(filePath, relativePath) {
     const parsed = this.parser.parse(filePath);
@@ -138,9 +183,9 @@ class ManualSyncHelper {
       name: parsed.name,
       type: parsed.type,
       tags: parsed.tags,
-      beforeEach: parsed.beforeEach,
+      before_each: parsed.before_each,
       path: relativePath,
-      test_cases: parsed.cases || [] // Map 'cases' to 'test_cases' for consistency
+      test_cases: parsed.test_cases || [] // Map 'cases' to 'test_cases' for consistency
     };
   }
 }

package/src/types.d.ts

@@ -0,0 +1,104 @@
+export type IManualTestCase = {
+  name: string;
+  type: string;
+  tags: string[];
+  steps: string[];
+  path: string;
+  hash: string;
+}
+
+export type IManualTestSuite = {
+  name: string;
+  type: string;
+  tags: string[];
+  before_each: string[];
+  test_cases: IManualTestCase[];
+  hash: string;
+}
+
+export type IManualTestFolder = {
+  name: string;
+  path: string;
+  test_suites: IManualTestSuite[];
+  folders: IManualTestFolder[];
+  hash: string;
+}
+
+export type IManualSyncComparePayload = {
+  project_id: string;
+  folders: IManualSyncCompareFolder[];
+}
+
+export type IManualSyncCompareFolder = {
+  name: string;
+  hash: string;
+  test_suites: IManualSyncCompareTestSuite[];
+  folders: IManualSyncCompareFolder[];
+}
+
+export type IManualSyncCompareTestSuite = {
+  name: string;
+  hash: string;
+}
+
+export type IManualSyncCompareTestCase = {
+  name: string;
+  hash: string;
+}
+
+export type IManualSyncCompareResponse = {
+  folders: IManualSyncCompareResponseFolder[];
+}
+
+export type SyncOperationType = 'create' | 'update' | 'delete' | 'no_change';
+
+export type IManualSyncCompareResponseFolder = {
+  type: SyncOperationType;
+  id?: string;
+  name: string;
+  hash: string;
+  test_suites: IManualSyncCompareResponseTestSuite[];
+  folders: IManualSyncCompareResponseFolder[];
+}
+
+export type IManualSyncCompareResponseTestSuite = {
+  type: SyncOperationType;
+  id?: string;
+  name: string;
+  hash: string;
+}
+
+export type IManualSyncFoldersPayload = {
+  project_id: string;
+  folders: IManualSyncFoldersFolder[];
+}
+
+export type IManualSyncFoldersFolder = {
+  type: SyncOperationType;
+  name: string;
+  path: string;
+  hash: string;
+  id?: string;
+}
+
+export type ISyncManualSuitesPayload = {
+  project_id: string;
+  suites: ISyncManualSuitesSuite[];
+}
+
+export type ISyncManualSuitesSuite = {
+  type: SyncOperationType;
+  name: string;
+  folder_id: string;
+  hash: string;
+  tags?: string[];
+  before_each?: string[];
+  test_cases?: ISyncManualSuitesTestCase[];
+}
+
+export type ISyncManualSuitesTestCase = {
+  name: string;
+  hash: string;
+  tags?: string[];
+  steps: string[];
+}