mbkbucket 1.5.1 → 2.1.0

package/lib/config/index.js

@@ -1,7 +1,10 @@
 import { createRequire } from "module";
 import dotenv from "dotenv";
+import { parseAndValidateMbkbucketVar, parseAndValidateBucketConnection } from "./validation.js";
+import { createLogger } from "../debug.js";
 
 dotenv.config();
+const debugConfig = createLogger('config');
 
 // Load package.json from mbkbucket package (not parent project)
 const require = createRequire(import.meta.url);
@@ -27,19 +30,31 @@ try {
     }
 }
 
+function compareVersions(a, b) {
+    const left = String(a || '').split(/[.-]/).map((part) => parseInt(part, 10) || 0);
+    const right = String(b || '').split(/[.-]/).map((part) => parseInt(part, 10) || 0);
+    const length = Math.max(left.length, right.length);
+
+    for (let i = 0; i < length; i += 1) {
+        const diff = (left[i] || 0) - (right[i] || 0);
+        if (diff !== 0) return diff;
+    }
+    return 0;
+}
+
 // Fetch latest version from GitHub
 async function getLatestVersion() {
   try {
     const response = await fetch('https://raw.githubusercontent.com/MIbnEKhalid/mbkbucket/master/package.json');
     if (!response.ok) {
-      console.error(`[mbkbucket] GitHub API responded with status ${response.status}`);
+      debugConfig('GitHub API responded with status %s', response.status);
       return "0.0.0";
     }
 
     const latestPackageJson = await response.json();
     return latestPackageJson.version;
   } catch (error) {
-    console.error('[mbkbucket] Error fetching latest version from GitHub:', error);
+    debugConfig('Error fetching latest version from GitHub: %s', error.message);
     return null;
   }
 }
@@ -48,90 +63,30 @@ async function getLatestVersion() {
 async function checkVersion() {
     try {
         const latestVersion = await getLatestVersion();
-        if (latestVersion && latestVersion !== packageJson.version) {
-            console.warn(`[mbkbucket] Current version (${packageJson.version}) is outdated. Latest version: ${latestVersion}. Consider updating mbkbucket.`);
+        if (latestVersion && compareVersions(latestVersion, packageJson.version) > 0) {
+            debugConfig('Current version (%s) is outdated. Latest version: %s.', packageJson.version, latestVersion);
+        } else if (latestVersion && compareVersions(latestVersion, packageJson.version) < 0) {
+            debugConfig('Current version (%s) is newer than published version: %s.', packageJson.version, latestVersion);
         } else if (latestVersion) {
-            console.info(`[mbkbucket] Running latest version (${packageJson.version}).`);
+            debugConfig('Running latest version (%s).', packageJson.version);
         }
     } catch (error) {
-        console.warn(`[mbkbucket] Failed to check for updates: ${error.message}`);
+        debugConfig('Failed to check for updates: %s', error.message);
     }
 }
 
 // Comprehensive validation function
 function validateConfiguration() {
-    const errors = [];
-
-    // Parse and validate mbkbucketVar
-    let mbkbucketVar;
     try {
+        const parsed = parseAndValidateMbkbucketVar(process.env.mbkbucketVar);
         if (!process.env.mbkbucketVar) {
-            // If mbkbucketVar is not defined, use empty object (defaults will be applied later)
-            mbkbucketVar = {};
-            console.log(`[mbkbucket] mbkbucketVar not defined, using defaults`);
-        } else {
-            mbkbucketVar = JSON.parse(process.env.mbkbucketVar);
+            debugConfig('mbkbucketVar not defined, using defaults');
         }
+        debugConfig('Configuration loaded');
+        return parsed;
     } catch (error) {
-        errors.push("Invalid JSON in process.env.mbkbucketVar");
-        throw new Error(`[mbkbucket] Configuration Error:\n  - ${errors.join('\n  - ')}`);
-    }
-
-    if (!mbkbucketVar || typeof mbkbucketVar !== 'object') {
-        errors.push("mbkbucketVar must be a valid object");
-        throw new Error(`[mbkbucket] Configuration Error:\n  - ${errors.join('\n  - ')}`);
+        throw new Error(`[mbkbucket] Configuration Validation Failed:\n  - ${error.message}`);
     }
-
-    // Apply defaults for optional keys (booleans now)
-    const defaults = {
-        p_view_inline: true,
-        publiView_enabled: false
-    };
-
-    const usedDefaults = [];
-    Object.entries(defaults).forEach(([key, defaultVal]) => {
-        const current = mbkbucketVar[key];
-        if (current === undefined || (typeof current === 'string' && current.trim() === '')) {
-            mbkbucketVar[key] = defaultVal;
-            usedDefaults.push(key);
-        }
-    });
-
-    // Helper to normalize various truthy/falsy representations
-    function normalizeBool(val) {
-        if (typeof val === 'boolean') return val;
-        if (typeof val === 'string') {
-            const norm = val.trim().toLowerCase();
-            if (['true', 't', '1', 'yes', 'y', 'on'].includes(norm)) return true;
-            if (['false', 'f', '0', 'no', 'n', 'off'].includes(norm)) return false;
-            return val; // return original so later validation will flag it
-        }
-        return val;
-    }
-
-    // Normalize boolean-like values early so validation works on cleaned values;
-    // results are actual booleans.
-    ['p_view_inline', 'publiView_enabled'].forEach(k => {
-        if (k in mbkbucketVar) {
-            mbkbucketVar[k] = normalizeBool(mbkbucketVar[k]);
-        }
-    });
-
-    // Validate that applied values are proper booleans (after defaults and normalization)
-    // Note: p_view_inline and publiView_enabled are optional - defaults are applied above
-    ['p_view_inline', 'publiView_enabled'].forEach(key => {
-        if (mbkbucketVar[key] !== undefined && typeof mbkbucketVar[key] !== 'boolean') {
-            errors.push(`mbkbucketVar.${key} must be a boolean if provided`);
-        }
-    });
-
-    if (errors.length > 0) {
-        throw new Error(`[mbkbucket] Configuration Validation Failed:\n  - ${errors.join('\n  - ')}`);
-    }
-
-    const summary = usedDefaults.length > 0 ? ` (defaults applied: ${usedDefaults.join(', ')})` : '';
-    console.log(`[mbkbucket] Configuration loaded${summary}`);
-    return mbkbucketVar;
 }
 
 // Validate BucketConnection configuration
@@ -144,30 +99,10 @@ function validateBucketConnection() {
     }
 
     try {
-        const bucketConfig = JSON.parse(process.env.BucketConnection);
-        
-        if (!bucketConfig || typeof bucketConfig !== 'object' || Object.keys(bucketConfig).length === 0) {
-            throw new Error('BucketConnection must be a non-empty object');
-        }
-
-        // Validate each bucket configuration
-        const bucketNames = Object.keys(bucketConfig);
-        for (const bucketName of bucketNames) {
-            const config = bucketConfig[bucketName];
-            
-            if (!config || typeof config !== 'object') {
-                throw new Error(`Bucket '${bucketName}' configuration must be an object, not a string. Remove quotes around the inner JSON object.`);
-            }
-            
-            const requiredFields = ['BUCKET_NAME', 'ACCESS_KEY_ID', 'SECRET_ACCESS_KEY', 'ENDPOINT'];
-            const missingFields = requiredFields.filter(field => !config[field]);
-            
-            if (missingFields.length > 0) {
-                throw new Error(`Bucket '${bucketName}' is missing required fields: ${missingFields.join(', ')}`);
-            }
-        }
+        const bucketConfig = parseAndValidateBucketConnection(process.env.BucketConnection);
+        const bucketNames = Object.keys(bucketConfig || {});
 
-        console.log(`[mbkbucket] ✓ BucketConnection validated (${bucketNames.length} bucket(s): ${bucketNames.join(', ')})`);
+        debugConfig('BucketConnection validated (%s bucket(s): %s)', bucketNames.length, bucketNames.join(', '));
         return bucketConfig;
     } catch (error) {
         console.error(`[mbkbucket] ❌ BucketConnection validation failed: ${error.message}`);
@@ -181,10 +116,11 @@ function validateBucketConnection() {
 
 // Parse and validate mbkbucketVar once
 const mbkbucketVar = validateConfiguration();
-console.log(`[mbkbucket] mbkbucketVar configuration:`, mbkbucketVar);
+debugConfig('mbkbucketVar configuration: %O', mbkbucketVar);
 
 // Validate BucketConnection
 validateBucketConnection();
 
 export { packageJson, appVersion, getLatestVersion, checkVersion };
-export { mbkbucketVar };
+export { mbkbucketVar };
+export { parseAndValidateMbkbucketVar, parseAndValidateBucketConnection };

package/lib/config/validation.js

@@ -0,0 +1,89 @@
+const TRUE_VALUES = new Set(['true', 't', '1', 'yes', 'y', 'on']);
+const FALSE_VALUES = new Set(['false', 'f', '0', 'no', 'n', 'off']);
+
+function normalizeBooleanLike(value) {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (TRUE_VALUES.has(normalized)) return true;
+    if (FALSE_VALUES.has(normalized)) return false;
+  }
+  return value;
+}
+
+export function parseAndValidateMbkbucketVar(rawValue) {
+  const errors = [];
+  let parsed;
+
+  try {
+    parsed = rawValue ? JSON.parse(rawValue) : {};
+  } catch {
+    throw new Error('Invalid JSON in process.env.mbkbucketVar');
+  }
+
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('mbkbucketVar must be a valid object');
+  }
+
+  const defaults = {
+    p_view_inline: true,
+    publiView_enabled: false
+  };
+
+  for (const [key, defaultVal] of Object.entries(defaults)) {
+    const current = parsed[key];
+    if (current === undefined || (typeof current === 'string' && current.trim() === '')) {
+      parsed[key] = defaultVal;
+    }
+  }
+
+  parsed.p_view_inline = normalizeBooleanLike(parsed.p_view_inline);
+  parsed.publiView_enabled = normalizeBooleanLike(parsed.publiView_enabled);
+
+  if (typeof parsed.p_view_inline !== 'boolean') {
+    errors.push('mbkbucketVar.p_view_inline must be a boolean if provided');
+  }
+  if (typeof parsed.publiView_enabled !== 'boolean') {
+    errors.push('mbkbucketVar.publiView_enabled must be a boolean if provided');
+  }
+
+  if (errors.length) {
+    throw new Error(errors.join(' | '));
+  }
+
+  return parsed;
+}
+
+export function parseAndValidateBucketConnection(rawValue) {
+  if (!rawValue) {
+    return null;
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(rawValue);
+  } catch {
+    throw new Error('BucketConnection is not valid JSON');
+  }
+
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || Object.keys(parsed).length === 0) {
+    throw new Error('BucketConnection must be a non-empty object');
+  }
+
+  const requiredFields = ['BUCKET_NAME', 'ACCESS_KEY_ID', 'SECRET_ACCESS_KEY', 'ENDPOINT'];
+
+  for (const [bucketName, config] of Object.entries(parsed)) {
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+      throw new Error(`Bucket '${bucketName}' configuration must be an object, not a string. Remove quotes around the inner JSON object.`);
+    }
+
+    const missingFields = requiredFields.filter((field) => !config[field]);
+    if (missingFields.length) {
+      throw new Error(`Bucket '${bucketName}' is missing required fields: ${missingFields.join(', ')}`);
+    }
+  }
+
+  return parsed;
+}
+
+export { normalizeBooleanLike };

package/lib/debug.js

@@ -0,0 +1,12 @@
+import createDebug from "debug";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+if (process.env.DEBUG) {
+  createDebug.enable(process.env.DEBUG);
+}
+
+export function createLogger(namespace) {
+  return createDebug(`mbkbucket:${namespace}`);
+}