feat: implement versioning

Author: maximka76667

electron-app/.gitignore

@@ -81,4 +81,5 @@ coverage
 
 # Config and config backups
 config.toml
-config.toml.backup-*
+config.toml.backup-*
+version.toml

electron-app/src/config/configInstance.js

@@ -4,8 +4,13 @@
  * Provides async wrappers for ConfigManager operations with lazy initialization.
  */
 
+import { app } from "electron";
 import { logger } from "../utils/logger.js";
-import { getTemplatePath, getUserConfigPath } from "../utils/paths.js";
+import {
+  getTemplatePath,
+  getUserConfigPath,
+  getVersionFilePath,
+} from "../utils/paths.js";
 
 // Store the singleton ConfigManager instance
 let configManager = null;
@@ -26,11 +31,19 @@ async function getConfigManager() {
     // Get paths for user config and template
     const userConfigPath = getUserConfigPath();
     const templatePath = getTemplatePath();
+    const versionFilePath = getVersionFilePath();
 
     // Create new ConfigManager instance
-    configManager = new ConfigManager(userConfigPath, templatePath);
+    configManager = new ConfigManager(
+      userConfigPath,
+      templatePath,
+      versionFilePath,
+      app.getVersion(),
+    );
+
     logger.config.info("ConfigManager initialized");
     logger.config.path("User config", userConfigPath);
+    logger.config.path("User version config", versionFilePath);
     logger.config.path("Template path", templatePath);
   }
 

electron-app/src/config/configManager.js

@@ -4,9 +4,9 @@
  * Handles reading, writing, and updating configuration files while maintaining formatting and comments.
  */
 
+import TOML from "@iarna/toml";
 import fs from "fs";
 import path from "path";
-import TOML from "@iarna/toml";
 import { logger } from "../utils/logger.js";
 
 /**
@@ -69,7 +69,7 @@ function updateTomlValue(tomlContent, section, key, newValue) {
 
     // Parse the line: key = value # comment
     const match = line.match(
-      /^(\s*)([a-zA-Z_][a-zA-Z0-9_-]*)(\s*=\s*)([^#]+?)((?:\s*#.*)?)$/
+      /^(\s*)([a-zA-Z_][a-zA-Z0-9_-]*)(\s*=\s*)([^#]+?)((?:\s*#.*)?)$/,
     );
 
     // Check if this line matches the key we're looking for
@@ -89,7 +89,7 @@ function updateTomlValue(tomlContent, section, key, newValue) {
       } else if (Array.isArray(newValue)) {
         // Simple array formatting
         const items = newValue.map((v) =>
-          typeof v === "string" ? `"${v}"` : v
+          typeof v === "string" ? `"${v}"` : v,
         );
         formattedValue = `[${items.join(", ")}]`;
       } else if (newValue === null || newValue === undefined) {
@@ -111,7 +111,7 @@ function updateTomlValue(tomlContent, section, key, newValue) {
   // Warn if key was not found
   if (!updated) {
     console.warn(
-      `Warning: Key "${key}" in section "${section || "root"}" not found`
+      `Warning: Key "${key}" in section "${section || "root"}" not found`,
     );
   }
 
@@ -165,13 +165,17 @@ class ConfigManager {
    * Creates a new ConfigManager instance.
    * @param {string} userConfigPath - Path to the user configuration file.
    * @param {string} templatePath - Path to the template configuration file.
+   * @param {string} versionFilePath - Path to the version.toml (app version)
+   * @param {string} appVersion - Current electron bundle version from package.json
    * @example
-   * const manager = new ConfigManager("/path/to/config.toml", "/path/to/template.toml");
+   * const manager = new ConfigManager("/path/to/config.toml", "/path/to/template.toml", "/path/to/version.toml" app.getVersion());
    */
-  constructor(userConfigPath, templatePath) {
+  constructor(userConfigPath, templatePath, versionFilePath, appVersion) {
     // Store paths
     this.userConfigPath = userConfigPath;
     this.templatePath = templatePath;
+    this.versionFilePath = versionFilePath;
+    this.appVersion = appVersion;
 
     // Ensure user config exists (copy from template on first run)
     this.ensureConfigExists();
@@ -192,16 +196,44 @@ class ConfigManager {
 
     // Copy template if user config doesn't exist
     if (!fs.existsSync(this.userConfigPath)) {
-      if (fs.existsSync(this.templatePath)) {
-        // Copy template to user config location
-        fs.copyFileSync(this.templatePath, this.userConfigPath);
-        logger.config.info(
-          `Created config from template: ${this.userConfigPath}`
-        );
-      } else {
-        // Throw error if template is missing
+      if (!fs.existsSync(this.templatePath)) {
         throw new Error(`Template not found: ${this.templatePath}`);
       }
+
+      // Copy template to user config location
+      fs.copyFileSync(this.templatePath, this.userConfigPath);
+      logger.config.info(
+        `Created config from template: ${this.userConfigPath}`,
+      );
+
+      fs.writeFileSync(
+        this.versionFilePath,
+        `version = "${this.appVersion}"`,
+        "utf-8",
+      );
+      logger.config.info(`Created app version file: ${this.versionFilePath}`);
+      return;
+    }
+
+    // If config does exist, get app's version
+    // In case version.toml doesn't exists it returns null
+    const storedVersion = fs.existsSync(this.versionFilePath)
+      ? (fs
+          .readFileSync(this.versionFilePath, "utf-8")
+          .trim()
+          .match(/^version\s*=\s*"(.+)"$/)?.[1] ?? null)
+      : null;
+
+    if (storedVersion !== this.appVersion) {
+      fs.copyFileSync(this.templatePath, this.userConfigPath);
+      fs.writeFileSync(
+        this.versionFilePath,
+        `version = "${this.appVersion}"`,
+        "utf-8",
+      );
+      logger.config.info(
+        `Config updated from template (from version ${storedVersion ?? "unknown"} to ${this.appVersion})`,
+      );
     }
   }
 
@@ -360,4 +392,4 @@ class ConfigManager {
   }
 }
 
-export { ConfigManager, updateTomlValue, updateTomlFromObject };
+export { ConfigManager, updateTomlFromObject, updateTomlValue };

electron-app/src/utils/paths.js

@@ -59,14 +59,14 @@ function getBinaryPath(name) {
     return path.join(
       getAppPath(),
       "binaries",
-      `${name}-${goos}-${goarch}${ext}`
+      `${name}-${goos}-${goarch}${ext}`,
     );
   }
 
   return path.join(
     process.resourcesPath,
     "binaries",
-    `${name}-${goos}-${goarch}${ext}`
+    `${name}-${goos}-${goarch}${ext}`,
   );
 }
 
@@ -90,6 +90,25 @@ function getUserConfigPath() {
   return path.join(configsDir, "config.toml");
 }
 
+/**
+ * Gets the path to the user app version file.
+ * @returns {string} The absolute path to the user's version.toml file.
+ * @example
+ * const configVersionPath = getVersionFilePath();
+ * // Development: returns "electron-app/version.toml"
+ * // Production: returns "userData/configs/version.toml"
+ */
+function getVersionFilePath() {
+  if (!app.isPackaged) {
+    // Development: use local config.toml in project root
+    return path.join(getAppPath(), "version.toml");
+  }
+
+  // Production: user config in userData directory
+  const userConfigDir = app.getPath("userData");
+  return path.join(userConfigDir, "version.toml");
+}
+
 /**
  * Gets the path to the configuration template file.
  * @returns {string} The absolute path to the configuration template file.
@@ -108,4 +127,10 @@ function getTemplatePath() {
   return path.join(process.resourcesPath, "config.toml");
 }
 
-export { getAppPath, getBinaryPath, getTemplatePath, getUserConfigPath };
+export {
+  getAppPath,
+  getBinaryPath,
+  getTemplatePath,
+  getUserConfigPath,
+  getVersionFilePath,
+};