@jeffusion/bungee-core 4.0.0 → 4.1.0

package/dist/master.js

@@ -16047,7 +16047,7 @@ var init_migrations = __esm(() => {
 });
 
 // src/config-migrations/types.ts
-var LATEST_CONFIG_VERSION = 2;
+var LATEST_CONFIG_VERSION = 4;
 
 // src/config-migrations/utils.ts
 function isPlainObject(value) {
@@ -16110,7 +16110,7 @@ function detectConfigVersion(rawConfig) {
   if (!isPlainObject(rawConfig)) {
     return 1;
   }
-  const version = rawConfig.configVersion;
+  const version = rawConfig.configVersion ?? rawConfig.config_version;
   return typeof version === "number" && Number.isInteger(version) && version > 0 ? version : 1;
 }
 function isPlainRecord(value) {
@@ -16151,7 +16151,7 @@ var init_v1_to_v2 = __esm(() => {
   ];
   v1ToV2Migration = {
     fromVersion: 1,
-    toVersion: LATEST_CONFIG_VERSION,
+    toVersion: 2,
     description: "Migrate legacy failover route fields to config model v2",
     migrate(input) {
       const config = cloneJson(input);
@@ -16184,7 +16184,259 @@ var init_v1_to_v2 = __esm(() => {
         }
         return cleanupEmptyObjects(migratedRoute);
       });
-      config.configVersion = LATEST_CONFIG_VERSION;
+      config.configVersion = 2;
+      return {
+        config: cleanupEmptyObjects(config),
+        changes,
+        warnings
+      };
+    }
+  };
+});
+
+// src/config-migrations/versions/v2-to-v3.ts
+function renameKeysRecursive(obj, mappings, changes) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => renameKeysRecursive(item, mappings, changes));
+  }
+  if (!isPlainRecord(obj)) {
+    return obj;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const mapping = mappings.find(([from]) => from === key);
+    const newKey = mapping ? mapping[1] : key;
+    if (mapping) {
+      changes.push({
+        type: "rename",
+        path: key,
+        from: key,
+        to: newKey,
+        message: `Renamed ${key} to ${newKey}`
+      });
+    }
+    result[newKey] = renameKeysRecursive(value, mappings, changes);
+  }
+  return result;
+}
+function migrateRoutesToServiceRef(config, changes, warnings) {
+  if (!Array.isArray(config.routes))
+    return;
+  const upstreamSignatureMap = new Map;
+  const services = [];
+  for (const route of config.routes) {
+    if (!isPlainRecord(route))
+      continue;
+    const endpoints = route.endpoints;
+    if (!Array.isArray(endpoints) || endpoints.length === 0) {
+      warnings.push({
+        path: `route "${route.path || "unknown"}"`,
+        message: "Route has no endpoints; skipping service extraction"
+      });
+      continue;
+    }
+    const signature = JSON.stringify(endpoints.map((u) => ({
+      target: u.target,
+      weight: u.weight,
+      priority: u.priority
+    })));
+    let serviceName = upstreamSignatureMap.get(signature);
+    if (!serviceName) {
+      serviceName = `service-${services.length + 1}`;
+      upstreamSignatureMap.set(signature, serviceName);
+      const service = {
+        name: serviceName,
+        endpoints
+      };
+      if (isPlainRecord(route.health_check)) {
+        service.health_check = route.health_check;
+      }
+      services.push(service);
+      changes.push({
+        type: "move",
+        path: `route "${route.path}".endpoints`,
+        from: "route.endpoints",
+        to: `services.${serviceName}.endpoints`,
+        message: `Extracted endpoints to service "${serviceName}"`
+      });
+    }
+    route.service = serviceName;
+    delete route.endpoints;
+  }
+  config.services = services;
+}
+var CAMEL_TO_SNAKE_MAPPINGS, v2ToV3Migration;
+var init_v2_to_v3 = __esm(() => {
+  CAMEL_TO_SNAKE_MAPPINGS = [
+    ["configVersion", "config_version"],
+    ["logLevel", "log_level"],
+    ["bodyParserLimit", "body_parser_limit"],
+    ["pathRewrite", "path_rewrite"],
+    ["stickySession", "sticky_session"],
+    ["keyExpression", "key_expression"],
+    ["connectMs", "connect_ms"],
+    ["requestMs", "request_ms"],
+    ["retryOn", "retry_on"],
+    ["passiveHealth", "passive_health"],
+    ["consecutiveFailures", "consecutive_failures"],
+    ["healthySuccesses", "healthy_successes"],
+    ["autoDisableThreshold", "auto_disable_threshold"],
+    ["autoEnableOnActiveHealthCheck", "auto_enable_on_active_health_check"],
+    ["probeIntervalMs", "probe_interval_ms"],
+    ["probeTimeoutMs", "probe_timeout_ms"],
+    ["slowStart", "slow_start"],
+    ["durationMs", "duration_ms"],
+    ["initialWeightFactor", "initial_weight_factor"],
+    ["healthCheck", "health_check"],
+    ["intervalMs", "interval_ms"],
+    ["timeoutMs", "timeout_ms"],
+    ["expectedStatus", "expected_status"],
+    ["unhealthyThreshold", "unhealthy_threshold"],
+    ["healthyThreshold", "healthy_threshold"],
+    ["contentType", "content_type"],
+    ["maxSize", "max_size"],
+    ["retentionDays", "retention_days"],
+    ["upstreams", "endpoints"]
+  ];
+  v2ToV3Migration = {
+    fromVersion: 2,
+    toVersion: 3,
+    description: "Migrate camelCase to snake_case and extract upstreams into services",
+    migrate(input) {
+      const config = cloneJson(input);
+      if (!isPlainRecord(config)) {
+        throw new Error("Config must be an object");
+      }
+      const changes = [];
+      const warnings = [];
+      const renamedConfig = renameKeysRecursive(config, CAMEL_TO_SNAKE_MAPPINGS, changes);
+      migrateRoutesToServiceRef(renamedConfig, changes, warnings);
+      renamedConfig.config_version = 3;
+      return {
+        config: cleanupEmptyObjects(renamedConfig),
+        changes,
+        warnings
+      };
+    }
+  };
+});
+
+// src/config-migrations/versions/v3-to-v4.ts
+function serviceNameFromPath(path6) {
+  const base = path6.replace(/^\/+/, "").replace(/\/+$/, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+  return `${base || "root"}-service`;
+}
+function uniqueServiceName(preferredName, existingNames) {
+  if (!existingNames.has(preferredName)) {
+    existingNames.add(preferredName);
+    return preferredName;
+  }
+  let suffix = 2;
+  while (existingNames.has(`${preferredName}-${suffix}`)) {
+    suffix++;
+  }
+  const name = `${preferredName}-${suffix}`;
+  existingNames.add(name);
+  return name;
+}
+function moveRouteConfigToService(route, service, routeIndex, changes) {
+  if (route.failover && !service.failover) {
+    service.failover = route.failover;
+    changes.push({
+      type: "move",
+      path: `routes.${routeIndex}.failover`,
+      from: `routes.${routeIndex}.failover`,
+      to: `services.${service.name}.failover`,
+      message: `Moved route failover to service "${service.name}"`
+    });
+  }
+  if (route.sticky_session && !service.sticky_session) {
+    service.sticky_session = route.sticky_session;
+    changes.push({
+      type: "move",
+      path: `routes.${routeIndex}.sticky_session`,
+      from: `routes.${routeIndex}.sticky_session`,
+      to: `services.${service.name}.sticky_session`,
+      message: `Moved route sticky_session to service "${service.name}"`
+    });
+  }
+  if (route.failover) {
+    delete route.failover;
+  }
+  if (route.sticky_session) {
+    delete route.sticky_session;
+  }
+}
+var v3ToV4Migration;
+var init_v3_to_v4 = __esm(() => {
+  v3ToV4Migration = {
+    fromVersion: 3,
+    toVersion: 4,
+    description: "Move failover and sticky_session from routes to services",
+    migrate(input) {
+      const config = cloneJson(input);
+      if (!isPlainRecord(config)) {
+        throw new Error("Config must be an object");
+      }
+      const changes = [];
+      const warnings = [];
+      const routes = Array.isArray(config.routes) ? config.routes : [];
+      const services = Array.isArray(config.services) ? config.services : [];
+      const serviceNames = new Set(services.map((service) => service.name));
+      for (let routeIndex = 0;routeIndex < routes.length; routeIndex++) {
+        const route = routes[routeIndex];
+        if (!isPlainRecord(route)) {
+          continue;
+        }
+        const hasRouteFailover = route.failover !== undefined;
+        const hasRouteStickySession = route.sticky_session !== undefined;
+        if (!hasRouteFailover && !hasRouteStickySession) {
+          continue;
+        }
+        if (route.service) {
+          let service2 = services.find((candidate) => candidate.name === route.service);
+          if (!service2) {
+            const routeEndpoints2 = route.endpoints ?? [];
+            service2 = {
+              name: route.service,
+              endpoints: routeEndpoints2
+            };
+            services.push(service2);
+            serviceNames.add(service2.name);
+            changes.push({
+              type: "move",
+              path: `routes.${routeIndex}.service`,
+              to: `services.${service2.name}`,
+              message: `Created missing service "${service2.name}" for route "${route.path}"`
+            });
+          }
+          moveRouteConfigToService(route, service2, routeIndex, changes);
+          continue;
+        }
+        const serviceName = uniqueServiceName(serviceNameFromPath(route.path), serviceNames);
+        const routeEndpoints = route.endpoints ?? [];
+        const service = {
+          name: serviceName,
+          endpoints: routeEndpoints,
+          ...route.failover && { failover: route.failover },
+          ...route.sticky_session && { sticky_session: route.sticky_session }
+        };
+        services.push(service);
+        route.service = serviceName;
+        delete route.endpoints;
+        changes.push({
+          type: "move",
+          path: `routes.${routeIndex}`,
+          from: `routes.${routeIndex}.endpoints/failover/sticky_session`,
+          to: `services.${serviceName}`,
+          message: `Created service "${serviceName}" from route "${route.path}"`
+        });
+        moveRouteConfigToService(route, service, routeIndex, changes);
+      }
+      if (services.length > 0) {
+        config.services = services;
+      }
+      config.config_version = 4;
       return {
         config: cleanupEmptyObjects(config),
         changes,
@@ -16198,8 +16450,12 @@ var init_v1_to_v2 = __esm(() => {
 var CONFIG_MIGRATIONS;
 var init_config_migrations = __esm(() => {
   init_v1_to_v2();
+  init_v2_to_v3();
+  init_v3_to_v4();
   CONFIG_MIGRATIONS = [
-    v1ToV2Migration
+    v1ToV2Migration,
+    v2ToV3Migration,
+    v3ToV4Migration
   ];
 });
 
@@ -16228,7 +16484,7 @@ function migrateConfigToLatest(rawConfig) {
   if (!isPlainRecord(workingConfig)) {
     throw new Error("Migrated config must be an object");
   }
-  workingConfig.configVersion = LATEST_CONFIG_VERSION;
+  workingConfig.config_version = LATEST_CONFIG_VERSION;
   return {
     config: workingConfig,
     originalVersion,
@@ -16251,105 +16507,119 @@ function ensurePositiveNumber(value, field, context) {
   }
   return value;
 }
-function normalizeRouteConfig(route) {
+function resolveRouteEndpoints(route, services) {
+  if (route.service) {
+    const svc = services?.find((s) => s.name === route.service);
+    if (!svc) {
+      logger.error(`Route "${route.path}" references unknown service "${route.service}".`);
+      process.exit(1);
+    }
+    return svc.endpoints;
+  }
+  const routeEndpoints = route.endpoints ?? [];
+  if (routeEndpoints.length > 0) {
+    return routeEndpoints;
+  }
+  if (route.direct_response?.enabled || route.redirect?.enabled || route.response_rules?.some((rule) => rule.enabled)) {
+    return [];
+  }
+  logger.error(`Route "${route.path}" must have "endpoints", "service", "response_rules", "direct_response", or "redirect" defined.`);
+  process.exit(1);
+}
+function normalizeRouteConfig(route, services) {
   route.timeouts ??= {};
-  route.failover ??= undefined;
-  for (const upstream of route.upstreams) {
-    if (upstream.weight === undefined) {
-      upstream.weight = 100;
+  const endpoints = resolveRouteEndpoints(route, services);
+  route.endpoints = endpoints;
+  for (const endpoint of endpoints) {
+    if (endpoint.weight === undefined) {
+      endpoint.weight = 100;
     }
-    if (upstream.priority === undefined) {
-      upstream.priority = 1;
+    if (endpoint.priority === undefined) {
+      endpoint.priority = 1;
     }
   }
   return route;
 }
-function validateStickySession(route) {
-  if (route.stickySession === undefined) {
+function validateStickySession(service) {
+  if (service.sticky_session === 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.`);
+  if (typeof service.sticky_session !== "object" || service.sticky_session === null || Array.isArray(service.sticky_session)) {
+    logger.error(`Invalid sticky_session config in service "${service.name}". sticky_session 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.`);
+  if (service.sticky_session.enabled !== undefined && typeof service.sticky_session.enabled !== "boolean") {
+    logger.error(`Invalid sticky_session.enabled in service "${service.name}". sticky_session.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.`);
+  if (service.sticky_session.key_expression !== undefined && typeof service.sticky_session.key_expression !== "string") {
+    logger.error(`Invalid sticky_session.key_expression in service "${service.name}". sticky_session.key_expression must be a string.`);
     process.exit(1);
   }
 }
-function validateFailoverConfig(route) {
-  const failover = route.failover;
+function validateFailoverConfig(service) {
+  const failover = service.failover;
   if (!failover) {
     return;
   }
   if (typeof failover.enabled !== "boolean") {
-    logger.error(`Invalid failover.enabled in route "${route.path}". failover.enabled must be a boolean.`);
+    logger.error(`Invalid failover.enabled in service "${service.name}". 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 (service.endpoints.length < 2 && failover.enabled) {
+    logger.warn(`Service "${service.name}" has failover enabled but less than 2 endpoints. Failover will not be active.`);
   }
-  if (route.timeouts?.connectMs !== undefined) {
-    ensurePositiveNumber(route.timeouts.connectMs, "timeouts.connectMs", `route "${route.path}"`);
+  if (failover.recovery?.probe_interval_ms !== undefined) {
+    ensurePositiveNumber(failover.recovery.probe_interval_ms, "failover.recovery.probe_interval_ms", `service "${service.name}"`);
   }
-  if (route.timeouts?.requestMs !== undefined) {
-    ensurePositiveNumber(route.timeouts.requestMs, "timeouts.requestMs", `route "${route.path}"`);
+  if (failover.recovery?.probe_timeout_ms !== undefined) {
+    ensurePositiveNumber(failover.recovery.probe_timeout_ms, "failover.recovery.probe_timeout_ms", `service "${service.name}"`);
   }
-  if (failover.recovery?.probeIntervalMs !== undefined) {
-    ensurePositiveNumber(failover.recovery.probeIntervalMs, "failover.recovery.probeIntervalMs", `route "${route.path}"`);
+  if (failover.passive_health?.consecutive_failures !== undefined) {
+    ensurePositiveNumber(failover.passive_health.consecutive_failures, "failover.passive_health.consecutive_failures", `service "${service.name}"`);
   }
-  if (failover.recovery?.probeTimeoutMs !== undefined) {
-    ensurePositiveNumber(failover.recovery.probeTimeoutMs, "failover.recovery.probeTimeoutMs", `route "${route.path}"`);
+  if (failover.passive_health?.healthy_successes !== undefined) {
+    ensurePositiveNumber(failover.passive_health.healthy_successes, "failover.passive_health.healthy_successes", `service "${service.name}"`);
   }
-  if (failover.passiveHealth?.consecutiveFailures !== undefined) {
-    ensurePositiveNumber(failover.passiveHealth.consecutiveFailures, "failover.passiveHealth.consecutiveFailures", `route "${route.path}"`);
+  if (failover.passive_health?.auto_disable_threshold !== undefined) {
+    ensurePositiveNumber(failover.passive_health.auto_disable_threshold, "failover.passive_health.auto_disable_threshold", `service "${service.name}"`);
   }
-  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.`);
+  if (failover.passive_health?.auto_enable_on_active_health_check !== undefined && typeof failover.passive_health.auto_enable_on_active_health_check !== "boolean") {
+    logger.error(`Invalid failover.passive_health.auto_enable_on_active_health_check in service "${service.name}". 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.`);
+  if (failover.slow_start) {
+    if (typeof failover.slow_start.enabled !== "boolean") {
+      logger.error(`Invalid failover.slow_start.enabled in service "${service.name}". 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.slow_start.duration_ms !== undefined) {
+      ensurePositiveNumber(failover.slow_start.duration_ms, "failover.slow_start.duration_ms", `service "${service.name}"`);
     }
-    if (failover.slowStart.initialWeightFactor !== undefined) {
-      const factor = failover.slowStart.initialWeightFactor;
+    if (failover.slow_start.initial_weight_factor !== undefined) {
+      const factor = failover.slow_start.initial_weight_factor;
       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.`);
+        logger.error(`failover.slow_start.initial_weight_factor in service "${service.name}" 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.`);
+  if (failover.health_check) {
+    if (typeof failover.health_check.enabled !== "boolean") {
+      logger.error(`Invalid failover.health_check.enabled in service "${service.name}". 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.health_check.interval_ms !== undefined) {
+      ensurePositiveNumber(failover.health_check.interval_ms, "failover.health_check.interval_ms", `service "${service.name}"`);
     }
-    if (failover.healthCheck.timeoutMs !== undefined) {
-      ensurePositiveNumber(failover.healthCheck.timeoutMs, "failover.healthCheck.timeoutMs", `route "${route.path}"`);
+    if (failover.health_check.timeout_ms !== undefined) {
+      ensurePositiveNumber(failover.health_check.timeout_ms, "failover.health_check.timeout_ms", `service "${service.name}"`);
     }
-    if (failover.healthCheck.unhealthyThreshold !== undefined) {
-      ensurePositiveNumber(failover.healthCheck.unhealthyThreshold, "failover.healthCheck.unhealthyThreshold", `route "${route.path}"`);
+    if (failover.health_check.unhealthy_threshold !== undefined) {
+      ensurePositiveNumber(failover.health_check.unhealthy_threshold, "failover.health_check.unhealthy_threshold", `service "${service.name}"`);
     }
-    if (failover.healthCheck.healthyThreshold !== undefined) {
-      ensurePositiveNumber(failover.healthCheck.healthyThreshold, "failover.healthCheck.healthyThreshold", `route "${route.path}"`);
+    if (failover.health_check.healthy_threshold !== undefined) {
+      ensurePositiveNumber(failover.health_check.healthy_threshold, "failover.health_check.healthy_threshold", `service "${service.name}"`);
     }
   }
 }
@@ -16377,44 +16647,92 @@ function validateAuthConfig(authConfig, context) {
   }
   logger.debug(`Auth config validated successfully for ${context}`);
 }
+function validateServices(services) {
+  const names = new Set;
+  for (const service of services) {
+    if (!service.name || typeof service.name !== "string") {
+      logger.error('Each service must have a non-empty "name" string.');
+      process.exit(1);
+    }
+    if (names.has(service.name)) {
+      logger.error(`Duplicate service name: "${service.name}". Service names must be unique.`);
+      process.exit(1);
+    }
+    names.add(service.name);
+    if (!service.endpoints || !Array.isArray(service.endpoints) || service.endpoints.length === 0) {
+      logger.error(`Service "${service.name}" must have a non-empty "endpoints" array.`);
+      process.exit(1);
+    }
+    for (const endpoint of service.endpoints) {
+      if (typeof endpoint.target !== "string") {
+        logger.error(`Invalid endpoint in service "${service.name}". Each endpoint must have a string "target".`);
+        process.exit(1);
+      }
+    }
+    validateStickySession(service);
+    validateFailoverConfig(service);
+  }
+}
 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.services && Array.isArray(config.services)) {
+    validateServices(config.services);
+  }
   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.`);
+    const hasEndpoints = route.endpoints && route.endpoints.length > 0;
+    const hasServiceRef = !!route.service;
+    const hasDirectResponse = !!route.direct_response?.enabled;
+    const hasRedirect = !!route.redirect?.enabled;
+    const hasResponseRules = !!route.response_rules?.some((rule) => rule.enabled);
+    if (!hasEndpoints && !hasServiceRef && !hasDirectResponse && !hasRedirect && !hasResponseRules) {
+      logger.error(`Route for path "${route.path}" must have "endpoints", "service", "response_rules", "direct_response", or "redirect" defined.`);
       process.exit(1);
     }
+    if (hasServiceRef && config.services) {
+      const svc = config.services.find((s) => s.name === route.service);
+      if (!svc) {
+        logger.error(`Route "${route.path}" references unknown service "${route.service}".`);
+        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);
+    normalizeRouteConfig(route, config.services);
+    if (route.timeouts?.connect_ms !== undefined) {
+      ensurePositiveNumber(route.timeouts.connect_ms, "timeouts.connect_ms", `route "${route.path}"`);
+    }
+    if (route.timeouts?.request_ms !== undefined) {
+      ensurePositiveNumber(route.timeouts.request_ms, "timeouts.request_ms", `route "${route.path}"`);
+    }
+    const endpoints = resolveRouteEndpoints(route, config.services);
+    if (endpoints.length > 0) {
+      let total_weight = 0;
+      for (const endpoint of endpoints) {
+        if (typeof endpoint.target !== "string") {
+          logger.error(`Invalid endpoint in route for path "${route.path}". Each endpoint must have a string "target".`);
+          process.exit(1);
+        }
+        if (typeof endpoint.weight !== "number" || endpoint.weight <= 0) {
+          logger.error(`Invalid weight in route for path "${route.path}". Weight must be a positive number.`);
+          process.exit(1);
+        }
+        if (typeof endpoint.priority !== "number" || endpoint.priority <= 0) {
+          logger.error(`Invalid priority in route for path "${route.path}". Priority must be a positive number.`);
+          process.exit(1);
+        }
+        total_weight += endpoint.weight;
       }
-      if (typeof upstream.priority !== "number" || upstream.priority <= 0) {
-        logger.error(`Invalid priority in route for path "${route.path}". Priority must be a positive number.`);
+      if (total_weight === 0) {
+        logger.error(`Total weight for endpoints in route "${route.path}" cannot be zero.`);
         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;
@@ -16431,7 +16749,7 @@ function preloadGlobalConfig() {
     const config = migrateConfigToLatest(rawConfig).config;
     const configMapping = [
       {
-        jsonKey: "logLevel",
+        jsonKey: "log_level",
         envKey: "LOG_LEVEL",
         default: "info",
         validate: (value) => ["trace", "debug", "info", "warn", "error", "fatal"].includes(value.toLowerCase())
@@ -16455,7 +16773,7 @@ function preloadGlobalConfig() {
         }
       },
       {
-        jsonKey: "bodyParserLimit",
+        jsonKey: "body_parser_limit",
         envKey: "BODY_PARSER_LIMIT",
         default: "50mb"
       }
@@ -16486,7 +16804,7 @@ async function loadConfig(configPath) {
     if (!fs6.existsSync(configFilePath)) {
       logger.info(`Config file not found at ${configFilePath}, creating empty configuration`);
       const minimalConfig = {
-        configVersion: 2,
+        config_version: 4,
         routes: []
       };
       fs6.writeFileSync(configFilePath, JSON.stringify(minimalConfig, null, 2), "utf-8");