@jeffusion/bungee-core 3.3.1 → 4.0.0

package/dist/master.js

@@ -16046,9 +16046,379 @@ var init_migrations = __esm(() => {
   ];
 });
 
+// src/config-migrations/types.ts
+var LATEST_CONFIG_VERSION = 2;
+
+// src/config-migrations/utils.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function getAtPath(obj, path6) {
+  if (!path6)
+    return obj;
+  return path6.split(".").reduce((current, segment) => {
+    if (!isPlainObject(current) && !Array.isArray(current)) {
+      return;
+    }
+    return current[segment];
+  }, obj);
+}
+function setAtPath(obj, path6, value) {
+  const segments = path6.split(".");
+  let current = obj;
+  for (let i = 0;i < segments.length - 1; i++) {
+    const segment = segments[i];
+    if (!isPlainObject(current[segment])) {
+      current[segment] = {};
+    }
+    current = current[segment];
+  }
+  current[segments[segments.length - 1]] = value;
+}
+function deleteAtPath(obj, path6) {
+  const segments = path6.split(".");
+  let current = obj;
+  for (let i = 0;i < segments.length - 1; i++) {
+    const segment = segments[i];
+    if (!isPlainObject(current[segment])) {
+      return;
+    }
+    current = current[segment];
+  }
+  delete current[segments[segments.length - 1]];
+}
+function cleanupEmptyObjects(value) {
+  if (Array.isArray(value)) {
+    return value.map(cleanupEmptyObjects);
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const cleanedEntries = Object.entries(value).map(([key, child]) => [key, cleanupEmptyObjects(child)]).filter(([, child]) => {
+    if (child === undefined)
+      return false;
+    if (isPlainObject(child) && Object.keys(child).length === 0)
+      return false;
+    return true;
+  });
+  return Object.fromEntries(cleanedEntries);
+}
+function detectConfigVersion(rawConfig) {
+  if (!isPlainObject(rawConfig)) {
+    return 1;
+  }
+  const version = rawConfig.configVersion;
+  return typeof version === "number" && Number.isInteger(version) && version > 0 ? version : 1;
+}
+function isPlainRecord(value) {
+  return isPlainObject(value);
+}
+
+// src/config-migrations/versions/v1-to-v2.ts
+function hasAnyValue(route, paths) {
+  return paths.some((path6) => getAtPath(route, path6) !== undefined);
+}
+function moveLegacyField(route, fromPath, toPath, changes) {
+  const currentValue = getAtPath(route, fromPath);
+  if (currentValue === undefined) {
+    return;
+  }
+  setAtPath(route, toPath, currentValue);
+  deleteAtPath(route, fromPath);
+  changes.push({
+    type: "move",
+    path: fromPath,
+    from: currentValue,
+    to: toPath,
+    message: `Moved ${fromPath} to ${toPath}`
+  });
+}
+var LEGACY_FIELD_MAPPINGS, v1ToV2Migration;
+var init_v1_to_v2 = __esm(() => {
+  LEGACY_FIELD_MAPPINGS = [
+    ["failover.requestTimeoutMs", "timeouts.requestMs"],
+    ["failover.connectTimeoutMs", "timeouts.connectMs"],
+    ["failover.retryableStatusCodes", "failover.retryOn"],
+    ["failover.consecutiveFailuresThreshold", "failover.passiveHealth.consecutiveFailures"],
+    ["failover.healthyThreshold", "failover.passiveHealth.healthySuccesses"],
+    ["failover.autoDisableThreshold", "failover.passiveHealth.autoDisableThreshold"],
+    ["failover.autoEnableOnHealthCheck", "failover.passiveHealth.autoEnableOnActiveHealthCheck"],
+    ["failover.recoveryIntervalMs", "failover.recovery.probeIntervalMs"],
+    ["failover.recoveryTimeoutMs", "failover.recovery.probeTimeoutMs"]
+  ];
+  v1ToV2Migration = {
+    fromVersion: 1,
+    toVersion: LATEST_CONFIG_VERSION,
+    description: "Migrate legacy failover route fields to config model v2",
+    migrate(input) {
+      const config = cloneJson(input);
+      if (!isPlainRecord(config)) {
+        throw new Error("Config must be an object");
+      }
+      if (!Array.isArray(config.routes)) {
+        throw new Error("Config routes must be an array");
+      }
+      const changes = [];
+      const warnings = [];
+      const newFieldPaths = [
+        "timeouts.requestMs",
+        "timeouts.connectMs",
+        "failover.retryOn",
+        "failover.passiveHealth",
+        "failover.recovery"
+      ];
+      const legacyFieldPaths = LEGACY_FIELD_MAPPINGS.map(([fromPath]) => fromPath);
+      config.routes = config.routes.map((route, routeIndex) => {
+        if (!isPlainRecord(route)) {
+          throw new Error(`Route #${routeIndex + 1} must be an object`);
+        }
+        const migratedRoute = cloneJson(route);
+        if (hasAnyValue(migratedRoute, legacyFieldPaths) && hasAnyValue(migratedRoute, newFieldPaths)) {
+          throw new Error(`Route "${migratedRoute.path || routeIndex}" mixes legacy and v2 failover fields`);
+        }
+        for (const [fromPath, toPath] of LEGACY_FIELD_MAPPINGS) {
+          moveLegacyField(migratedRoute, fromPath, toPath, changes);
+        }
+        return cleanupEmptyObjects(migratedRoute);
+      });
+      config.configVersion = LATEST_CONFIG_VERSION;
+      return {
+        config: cleanupEmptyObjects(config),
+        changes,
+        warnings
+      };
+    }
+  };
+});
+
+// src/config-migrations/index.ts
+var CONFIG_MIGRATIONS;
+var init_config_migrations = __esm(() => {
+  init_v1_to_v2();
+  CONFIG_MIGRATIONS = [
+    v1ToV2Migration
+  ];
+});
+
+// src/config-migrations/migrate-config.ts
+function buildMigrationMap(migrations2) {
+  return new Map(migrations2.map((migration4) => [migration4.fromVersion, migration4]));
+}
+function migrateConfigToLatest(rawConfig) {
+  const migrationMap = buildMigrationMap(CONFIG_MIGRATIONS);
+  const originalVersion = detectConfigVersion(rawConfig);
+  let currentVersion = originalVersion;
+  let workingConfig = cloneJson(rawConfig);
+  const changes = [];
+  const warnings = [];
+  while (currentVersion < LATEST_CONFIG_VERSION) {
+    const migration4 = migrationMap.get(currentVersion);
+    if (!migration4) {
+      throw new Error(`No config migration registered from version ${currentVersion}`);
+    }
+    const result = migration4.migrate(workingConfig);
+    workingConfig = result.config;
+    changes.push(...result.changes);
+    warnings.push(...result.warnings);
+    currentVersion = migration4.toVersion;
+  }
+  if (!isPlainRecord(workingConfig)) {
+    throw new Error("Migrated config must be an object");
+  }
+  workingConfig.configVersion = LATEST_CONFIG_VERSION;
+  return {
+    config: workingConfig,
+    originalVersion,
+    finalVersion: LATEST_CONFIG_VERSION,
+    changes,
+    warnings
+  };
+}
+var init_migrate_config = __esm(() => {
+  init_config_migrations();
+});
+
 // src/config.ts
 import fs6 from "fs";
 import path6 from "path";
+function ensurePositiveNumber(value, field, context) {
+  if (typeof value !== "number" || Number.isNaN(value) || value <= 0) {
+    logger.error(`${field} in ${context} must be a positive number.`);
+    process.exit(1);
+  }
+  return value;
+}
+function normalizeRouteConfig(route) {
+  route.timeouts ??= {};
+  route.failover ??= undefined;
+  for (const upstream of route.upstreams) {
+    if (upstream.weight === undefined) {
+      upstream.weight = 100;
+    }
+    if (upstream.priority === undefined) {
+      upstream.priority = 1;
+    }
+  }
+  return route;
+}
+function validateStickySession(route) {
+  if (route.stickySession === undefined) {
+    return;
+  }
+  if (typeof route.stickySession !== "object" || route.stickySession === null || Array.isArray(route.stickySession)) {
+    logger.error(`Invalid stickySession config in route "${route.path}". stickySession must be an object.`);
+    process.exit(1);
+  }
+  if (route.stickySession.enabled !== undefined && typeof route.stickySession.enabled !== "boolean") {
+    logger.error(`Invalid stickySession.enabled in route "${route.path}". stickySession.enabled must be a boolean.`);
+    process.exit(1);
+  }
+  if (route.stickySession.keyExpression !== undefined && typeof route.stickySession.keyExpression !== "string") {
+    logger.error(`Invalid stickySession.keyExpression in route "${route.path}". stickySession.keyExpression must be a string.`);
+    process.exit(1);
+  }
+}
+function validateFailoverConfig(route) {
+  const failover = route.failover;
+  if (!failover) {
+    return;
+  }
+  if (typeof failover.enabled !== "boolean") {
+    logger.error(`Invalid failover.enabled in route "${route.path}". failover.enabled must be a boolean.`);
+    process.exit(1);
+  }
+  if (route.upstreams.length < 2 && failover.enabled) {
+    logger.warn(`Route for path "${route.path}" has failover enabled but less than 2 upstreams. Failover will not be active.`);
+  }
+  if (route.timeouts?.connectMs !== undefined) {
+    ensurePositiveNumber(route.timeouts.connectMs, "timeouts.connectMs", `route "${route.path}"`);
+  }
+  if (route.timeouts?.requestMs !== undefined) {
+    ensurePositiveNumber(route.timeouts.requestMs, "timeouts.requestMs", `route "${route.path}"`);
+  }
+  if (failover.recovery?.probeIntervalMs !== undefined) {
+    ensurePositiveNumber(failover.recovery.probeIntervalMs, "failover.recovery.probeIntervalMs", `route "${route.path}"`);
+  }
+  if (failover.recovery?.probeTimeoutMs !== undefined) {
+    ensurePositiveNumber(failover.recovery.probeTimeoutMs, "failover.recovery.probeTimeoutMs", `route "${route.path}"`);
+  }
+  if (failover.passiveHealth?.consecutiveFailures !== undefined) {
+    ensurePositiveNumber(failover.passiveHealth.consecutiveFailures, "failover.passiveHealth.consecutiveFailures", `route "${route.path}"`);
+  }
+  if (failover.passiveHealth?.healthySuccesses !== undefined) {
+    ensurePositiveNumber(failover.passiveHealth.healthySuccesses, "failover.passiveHealth.healthySuccesses", `route "${route.path}"`);
+  }
+  if (failover.passiveHealth?.autoDisableThreshold !== undefined) {
+    ensurePositiveNumber(failover.passiveHealth.autoDisableThreshold, "failover.passiveHealth.autoDisableThreshold", `route "${route.path}"`);
+  }
+  if (failover.passiveHealth?.autoEnableOnActiveHealthCheck !== undefined && typeof failover.passiveHealth.autoEnableOnActiveHealthCheck !== "boolean") {
+    logger.error(`Invalid failover.passiveHealth.autoEnableOnActiveHealthCheck in route "${route.path}". It must be a boolean.`);
+    process.exit(1);
+  }
+  if (failover.slowStart) {
+    if (typeof failover.slowStart.enabled !== "boolean") {
+      logger.error(`Invalid failover.slowStart.enabled in route "${route.path}". It must be a boolean.`);
+      process.exit(1);
+    }
+    if (failover.slowStart.durationMs !== undefined) {
+      ensurePositiveNumber(failover.slowStart.durationMs, "failover.slowStart.durationMs", `route "${route.path}"`);
+    }
+    if (failover.slowStart.initialWeightFactor !== undefined) {
+      const factor = failover.slowStart.initialWeightFactor;
+      if (typeof factor !== "number" || Number.isNaN(factor) || factor <= 0 || factor > 1) {
+        logger.error(`failover.slowStart.initialWeightFactor in route "${route.path}" must be between 0 and 1.`);
+        process.exit(1);
+      }
+    }
+  }
+  if (failover.healthCheck) {
+    if (typeof failover.healthCheck.enabled !== "boolean") {
+      logger.error(`Invalid failover.healthCheck.enabled in route "${route.path}". It must be a boolean.`);
+      process.exit(1);
+    }
+    if (failover.healthCheck.intervalMs !== undefined) {
+      ensurePositiveNumber(failover.healthCheck.intervalMs, "failover.healthCheck.intervalMs", `route "${route.path}"`);
+    }
+    if (failover.healthCheck.timeoutMs !== undefined) {
+      ensurePositiveNumber(failover.healthCheck.timeoutMs, "failover.healthCheck.timeoutMs", `route "${route.path}"`);
+    }
+    if (failover.healthCheck.unhealthyThreshold !== undefined) {
+      ensurePositiveNumber(failover.healthCheck.unhealthyThreshold, "failover.healthCheck.unhealthyThreshold", `route "${route.path}"`);
+    }
+    if (failover.healthCheck.healthyThreshold !== undefined) {
+      ensurePositiveNumber(failover.healthCheck.healthyThreshold, "failover.healthCheck.healthyThreshold", `route "${route.path}"`);
+    }
+  }
+}
+function validateAuthConfig(authConfig, context) {
+  if (authConfig.enabled === undefined) {
+    logger.error(`Auth config in ${context} must have an "enabled" field.`);
+    process.exit(1);
+  }
+  if (!authConfig.enabled) {
+    return;
+  }
+  if (!authConfig.tokens || !Array.isArray(authConfig.tokens)) {
+    logger.error(`Auth config in ${context} must have a "tokens" array when enabled.`);
+    process.exit(1);
+  }
+  if (authConfig.tokens.length === 0) {
+    logger.error(`Auth config in ${context} must have at least one token in the "tokens" array.`);
+    process.exit(1);
+  }
+  for (let i = 0;i < authConfig.tokens.length; i++) {
+    if (typeof authConfig.tokens[i] !== "string") {
+      logger.error(`Token at index ${i} in ${context} auth config must be a string.`);
+      process.exit(1);
+    }
+  }
+  logger.debug(`Auth config validated successfully for ${context}`);
+}
+function validateAndNormalizeConfig(config) {
+  if (!config.routes || !Array.isArray(config.routes)) {
+    logger.error('Error: "routes" is not defined or not an array in config.json.');
+    process.exit(1);
+  }
+  if (config.auth) {
+    validateAuthConfig(config.auth, "global");
+  }
+  for (const route of config.routes) {
+    if (!route.upstreams || route.upstreams.length === 0) {
+      logger.error(`Route for path "${route.path}" must have a non-empty "upstreams" array.`);
+      process.exit(1);
+    }
+    if (route.auth) {
+      validateAuthConfig(route.auth, `route "${route.path}"`);
+    }
+    validateStickySession(route);
+    validateFailoverConfig(route);
+    normalizeRouteConfig(route);
+    let totalWeight = 0;
+    for (const upstream of route.upstreams) {
+      if (typeof upstream.target !== "string") {
+        logger.error(`Invalid upstream in route for path "${route.path}". Each upstream must have a string "target".`);
+        process.exit(1);
+      }
+      if (typeof upstream.weight !== "number" || upstream.weight <= 0) {
+        logger.error(`Invalid weight in route for path "${route.path}". Weight must be a positive number.`);
+        process.exit(1);
+      }
+      if (typeof upstream.priority !== "number" || upstream.priority <= 0) {
+        logger.error(`Invalid priority in route for path "${route.path}". Priority must be a positive number.`);
+        process.exit(1);
+      }
+      totalWeight += upstream.weight;
+    }
+    if (totalWeight === 0) {
+      logger.error(`Total weight for upstreams in route "${route.path}" cannot be zero.`);
+      process.exit(1);
+    }
+  }
+  return config;
+}
 function preloadGlobalConfig() {
   try {
     const configPath = process.env.CONFIG_PATH || path6.resolve(process.cwd(), "config.json");
@@ -16057,7 +16427,8 @@ function preloadGlobalConfig() {
       return;
     }
     const configContent = fs6.readFileSync(configPath, "utf-8");
-    const config = JSON.parse(configContent);
+    const rawConfig = JSON.parse(configContent);
+    const config = migrateConfigToLatest(rawConfig).config;
     const configMapping = [
       {
         jsonKey: "logLevel",
@@ -16109,36 +16480,13 @@ function preloadGlobalConfig() {
     console.log("Falling back to environment variables and defaults.");
   }
 }
-function validateAuthConfig(authConfig, context) {
-  if (authConfig.enabled === undefined) {
-    logger.error(`Auth config in ${context} must have an "enabled" field.`);
-    process.exit(1);
-  }
-  if (!authConfig.enabled) {
-    return;
-  }
-  if (!authConfig.tokens || !Array.isArray(authConfig.tokens)) {
-    logger.error(`Auth config in ${context} must have a "tokens" array when enabled.`);
-    process.exit(1);
-  }
-  if (authConfig.tokens.length === 0) {
-    logger.error(`Auth config in ${context} must have at least one token in the "tokens" array.`);
-    process.exit(1);
-  }
-  for (let i = 0;i < authConfig.tokens.length; i++) {
-    if (typeof authConfig.tokens[i] !== "string") {
-      logger.error(`Token at index ${i} in ${context} auth config must be a string.`);
-      process.exit(1);
-    }
-  }
-  logger.debug(`Auth config validated successfully for ${context}`);
-}
 async function loadConfig(configPath) {
   try {
     const configFilePath = configPath || process.env.CONFIG_PATH || "config.json";
     if (!fs6.existsSync(configFilePath)) {
       logger.info(`Config file not found at ${configFilePath}, creating empty configuration`);
       const minimalConfig = {
+        configVersion: 2,
         routes: []
       };
       fs6.writeFileSync(configFilePath, JSON.stringify(minimalConfig, null, 2), "utf-8");
@@ -16146,65 +16494,16 @@ async function loadConfig(configPath) {
       logger.warn(`\u26A0\uFE0F  No routes configured. Please add routes via the web UI at http://localhost:${process.env.PORT || 8088}`);
       logger.info(`\uD83D\uDCDD Built-in endpoints: /health (health check), / (web UI)`);
     }
-    const config = await Bun.file(configFilePath).json();
-    if (!config.routes || !Array.isArray(config.routes)) {
-      logger.error('Error: "routes" is not defined or not an array in config.json.');
-      process.exit(1);
-    }
-    if (config.auth) {
-      validateAuthConfig(config.auth, "global");
-    }
-    for (const route of config.routes) {
-      if (!route.upstreams || route.upstreams.length === 0) {
-        logger.error(`Route for path "${route.path}" must have a non-empty "upstreams" array.`);
-        process.exit(1);
-      }
-      if (route.upstreams.length < 2 && route.failover?.enabled) {
-        logger.warn(`Route for path "${route.path}" has failover enabled but less than 2 upstreams. Failover will not be active.`);
-      }
-      if (route.auth) {
-        validateAuthConfig(route.auth, `route "${route.path}"`);
-      }
-      if (route.stickySession !== undefined) {
-        if (typeof route.stickySession !== "object" || route.stickySession === null || Array.isArray(route.stickySession)) {
-          logger.error(`Invalid stickySession config in route "${route.path}". stickySession must be an object.`);
-          process.exit(1);
-        }
-        if (route.stickySession.enabled !== undefined && typeof route.stickySession.enabled !== "boolean") {
-          logger.error(`Invalid stickySession.enabled in route "${route.path}". stickySession.enabled must be a boolean.`);
-          process.exit(1);
-        }
-        if (route.stickySession.keyExpression !== undefined && typeof route.stickySession.keyExpression !== "string") {
-          logger.error(`Invalid stickySession.keyExpression in route "${route.path}". stickySession.keyExpression must be a string.`);
-          process.exit(1);
-        }
-      }
-      let totalWeight = 0;
-      for (const upstream of route.upstreams) {
-        if (typeof upstream.target !== "string") {
-          logger.error(`Invalid upstream in route for path "${route.path}". Each upstream must have a string "target".`);
-          process.exit(1);
-        }
-        if (upstream.weight === undefined) {
-          upstream.weight = 100;
-        } else if (typeof upstream.weight !== "number" || upstream.weight <= 0) {
-          logger.error(`Invalid weight in route for path "${route.path}". Weight must be a positive number.`);
-          process.exit(1);
-        }
-        if (upstream.priority === undefined) {
-          upstream.priority = 1;
-        } else if (typeof upstream.priority !== "number" || upstream.priority <= 0) {
-          logger.error(`Invalid priority in route for path "${route.path}". Priority must be a positive number.`);
-          process.exit(1);
-        }
-        totalWeight += upstream.weight;
-      }
-      if (totalWeight === 0) {
-        logger.error(`Total weight for upstreams in route "${route.path}" cannot be zero.`);
-        process.exit(1);
-      }
+    const rawConfig = await Bun.file(configFilePath).json();
+    const migrated = migrateConfigToLatest(rawConfig);
+    if (migrated.originalVersion !== migrated.finalVersion) {
+      logger.info({
+        fromVersion: migrated.originalVersion,
+        toVersion: migrated.finalVersion,
+        changeCount: migrated.changes.length
+      }, "Config migrated to latest version in memory");
     }
-    return config;
+    return validateAndNormalizeConfig(migrated.config);
   } catch (error) {
     logger.fatal({ error }, "Failed to load or parse config.json. Please ensure it exists and is valid JSON.");
     process.exit(1);
@@ -16212,6 +16511,7 @@ async function loadConfig(configPath) {
 }
 var init_config = __esm(() => {
   init_logger();
+  init_migrate_config();
 });
 
 // src/plugin-storage-cleanup.ts