@jeffusion/bungee-core 4.2.0 → 4.3.0

package/dist/master.js

@@ -16341,7 +16341,43 @@ function uniqueServiceName(preferredName, existingNames) {
 }
 function moveRouteConfigToService(route, service, routeIndex, changes) {
   if (route.failover && !service.failover) {
-    service.failover = route.failover;
+    const failover = route.failover;
+    if (isPlainRecord(failover.health_check) && !service.health_check) {
+      service.health_check = failover.health_check;
+      changes.push({
+        type: "move",
+        path: `routes.${routeIndex}.failover.health_check`,
+        from: `routes.${routeIndex}.failover.health_check`,
+        to: `services.${service.name}.health_check`,
+        message: `Extracted health_check from failover to service "${service.name}" top-level`
+      });
+      delete failover.health_check;
+    }
+    if (failover.passive_health?.auto_enable_on_active_health_check !== undefined) {
+      if (service.health_check) {
+        service.health_check.auto_enable_on_active_health_check = failover.passive_health.auto_enable_on_active_health_check;
+        changes.push({
+          type: "move",
+          path: `routes.${routeIndex}.failover.passive_health.auto_enable_on_active_health_check`,
+          from: "failover.passive_health.auto_enable_on_active_health_check",
+          to: `services.${service.name}.health_check.auto_enable_on_active_health_check`,
+          message: `Moved auto_enable_on_active_health_check from passive_health to health_check`
+        });
+      }
+      delete failover.passive_health.auto_enable_on_active_health_check;
+    }
+    if (failover.recovery?.probe_interval_ms !== undefined) {
+      failover.recovery.backoff_base_ms = failover.recovery.probe_interval_ms;
+      delete failover.recovery.probe_interval_ms;
+      changes.push({
+        type: "rename",
+        path: `routes.${routeIndex}.failover.recovery.probe_interval_ms`,
+        from: "probe_interval_ms",
+        to: "backoff_base_ms",
+        message: `Renamed probe_interval_ms to backoff_base_ms (semantics: exponential backoff base)`
+      });
+    }
+    service.failover = failover;
     changes.push({
       type: "move",
       path: `routes.${routeIndex}.failover`,
@@ -16350,14 +16386,18 @@ function moveRouteConfigToService(route, service, routeIndex, changes) {
       message: `Moved route failover to service "${service.name}"`
     });
   }
-  if (route.sticky_session && !service.sticky_session) {
-    service.sticky_session = route.sticky_session;
+  if (route.sticky_session && !service.load_balancing) {
+    const key_expression = route.sticky_session.key_expression;
+    service.load_balancing = {
+      policy: "consistent_hash",
+      ...key_expression ? { hash_policy: { expression: key_expression } } : {}
+    };
     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}"`
+      to: `services.${service.name}.load_balancing`,
+      message: `Migrated route sticky_session to service "${service.name}" as load_balancing.policy=consistent_hash`
     });
   }
   if (route.failover) {
@@ -16372,7 +16412,7 @@ var init_v3_to_v4 = __esm(() => {
   v3ToV4Migration = {
     fromVersion: 3,
     toVersion: 4,
-    description: "Move failover and sticky_session from routes to services",
+    description: "Move failover and migrate sticky_session to load_balancing.consistent_hash on services",
     migrate(input) {
       const config = cloneJson(input);
       if (!isPlainRecord(config)) {
@@ -16415,11 +16455,26 @@ var init_v3_to_v4 = __esm(() => {
         }
         const serviceName = uniqueServiceName(serviceNameFromPath(route.path), serviceNames);
         const routeEndpoints = route.endpoints ?? [];
+        const failover = route.failover;
+        const extractedHealthCheck = isPlainRecord(failover?.health_check) ? failover.health_check : undefined;
+        if (extractedHealthCheck) {
+          delete failover.health_check;
+        }
+        if (failover?.recovery?.probe_interval_ms !== undefined) {
+          failover.recovery.backoff_base_ms = failover.recovery.probe_interval_ms;
+          delete failover.recovery.probe_interval_ms;
+        }
         const service = {
           name: serviceName,
           endpoints: routeEndpoints,
-          ...route.failover && { failover: route.failover },
-          ...route.sticky_session && { sticky_session: route.sticky_session }
+          ...failover && { failover },
+          ...extractedHealthCheck && { health_check: extractedHealthCheck },
+          ...route.sticky_session && {
+            load_balancing: {
+              policy: "consistent_hash",
+              ...route.sticky_session.key_expression ? { hash_policy: { expression: route.sticky_session.key_expression } } : {}
+            }
+          }
         };
         services.push(service);
         route.service = serviceName;
@@ -16429,7 +16484,7 @@ var init_v3_to_v4 = __esm(() => {
           path: `routes.${routeIndex}`,
           from: `routes.${routeIndex}.endpoints/failover/sticky_session`,
           to: `services.${serviceName}`,
-          message: `Created service "${serviceName}" from route "${route.path}"`
+          message: `Created service "${serviceName}" from route "${route.path}" (sticky_session migrated to load_balancing${extractedHealthCheck ? ", health_check extracted" : ""})`
         });
         moveRouteConfigToService(route, service, routeIndex, changes);
       }
@@ -19355,33 +19410,6 @@ var init_sortBy = __esm(() => {
   sortBy_default = sortBy;
 });
 
-// ../../node_modules/lodash-es/_baseSum.js
-function baseSum(array, iteratee) {
-  var result, index = -1, length = array.length;
-  while (++index < length) {
-    var current = iteratee(array[index]);
-    if (current !== undefined) {
-      result = result === undefined ? current : result + current;
-    }
-  }
-  return result;
-}
-var _baseSum_default;
-var init__baseSum = __esm(() => {
-  _baseSum_default = baseSum;
-});
-
-// ../../node_modules/lodash-es/sumBy.js
-function sumBy(array, iteratee) {
-  return array && array.length ? _baseSum_default(array, _baseIteratee_default(iteratee, 2)) : 0;
-}
-var sumBy_default;
-var init_sumBy = __esm(() => {
-  init__baseIteratee();
-  init__baseSum();
-  sumBy_default = sumBy;
-});
-
 // ../../node_modules/lodash-es/lodash.js
 var init_lodash = __esm(() => {
   init_find();
@@ -19392,7 +19420,6 @@ var init_lodash = __esm(() => {
   init_map();
   init_mergeWith();
   init_sortBy();
-  init_sumBy();
 });
 
 // src/expression-engine.ts
@@ -19794,21 +19821,29 @@ function normalizeRouteConfig(route, services) {
   }
   return route;
 }
-function validateStickySession(service) {
-  if (service.sticky_session === undefined) {
+function validateLoadBalancing(service) {
+  const lb = service.load_balancing;
+  if (!lb)
     return;
-  }
-  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 (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.`);
+  const validPolicies = ["weighted_random", "round_robin", "least_requests", "consistent_hash"];
+  if (!validPolicies.includes(lb.policy)) {
+    logger.error(`Invalid load_balancing.policy "${lb.policy}" in service "${service.name}". Must be one of: ${validPolicies.join(", ")}`);
     process.exit(1);
   }
-  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);
+  if (lb.policy === "consistent_hash") {
+    const hp = lb.hash_policy;
+    if (!hp || !hp.header && !hp.expression) {
+      logger.error(`Service "${service.name}" with policy=consistent_hash requires hash_policy with at least one of header or expression.`);
+      process.exit(1);
+    }
+    if (hp.header !== undefined && typeof hp.header !== "string") {
+      logger.error(`Invalid load_balancing.hash_policy.header in service "${service.name}". Must be a string.`);
+      process.exit(1);
+    }
+    if (hp.expression !== undefined && typeof hp.expression !== "string") {
+      logger.error(`Invalid load_balancing.hash_policy.expression in service "${service.name}". Must be a string.`);
+      process.exit(1);
+    }
   }
 }
 function validateFailoverConfig(service) {
@@ -19823,8 +19858,8 @@ function validateFailoverConfig(service) {
   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 (failover.recovery?.probe_interval_ms !== undefined) {
-    ensurePositiveNumber(failover.recovery.probe_interval_ms, "failover.recovery.probe_interval_ms", `service "${service.name}"`);
+  if (failover.recovery?.backoff_base_ms !== undefined) {
+    ensurePositiveNumber(failover.recovery.backoff_base_ms, "failover.recovery.backoff_base_ms", `service "${service.name}"`);
   }
   if (failover.recovery?.probe_timeout_ms !== undefined) {
     ensurePositiveNumber(failover.recovery.probe_timeout_ms, "failover.recovery.probe_timeout_ms", `service "${service.name}"`);
@@ -19838,10 +19873,6 @@ function validateFailoverConfig(service) {
   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.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.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.`);
@@ -19858,23 +19889,26 @@ function validateFailoverConfig(service) {
       }
     }
   }
-  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.health_check.interval_ms !== undefined) {
-      ensurePositiveNumber(failover.health_check.interval_ms, "failover.health_check.interval_ms", `service "${service.name}"`);
-    }
-    if (failover.health_check.timeout_ms !== undefined) {
-      ensurePositiveNumber(failover.health_check.timeout_ms, "failover.health_check.timeout_ms", `service "${service.name}"`);
-    }
-    if (failover.health_check.unhealthy_threshold !== undefined) {
-      ensurePositiveNumber(failover.health_check.unhealthy_threshold, "failover.health_check.unhealthy_threshold", `service "${service.name}"`);
-    }
-    if (failover.health_check.healthy_threshold !== undefined) {
-      ensurePositiveNumber(failover.health_check.healthy_threshold, "failover.health_check.healthy_threshold", `service "${service.name}"`);
-    }
+}
+function validateServiceHealthCheck(service) {
+  const hc = service.health_check;
+  if (!hc)
+    return;
+  if (typeof hc.enabled !== "boolean") {
+    logger.error(`Invalid health_check.enabled in service "${service.name}". It must be a boolean.`);
+    process.exit(1);
+  }
+  if (hc.interval_ms !== undefined)
+    ensurePositiveNumber(hc.interval_ms, "health_check.interval_ms", `service "${service.name}"`);
+  if (hc.timeout_ms !== undefined)
+    ensurePositiveNumber(hc.timeout_ms, "health_check.timeout_ms", `service "${service.name}"`);
+  if (hc.unhealthy_threshold !== undefined)
+    ensurePositiveNumber(hc.unhealthy_threshold, "health_check.unhealthy_threshold", `service "${service.name}"`);
+  if (hc.healthy_threshold !== undefined)
+    ensurePositiveNumber(hc.healthy_threshold, "health_check.healthy_threshold", `service "${service.name}"`);
+  if (hc.auto_enable_on_active_health_check !== undefined && typeof hc.auto_enable_on_active_health_check !== "boolean") {
+    logger.error(`Invalid health_check.auto_enable_on_active_health_check in service "${service.name}". It must be a boolean.`);
+    process.exit(1);
   }
 }
 function validateAuthConfig(authConfig, context) {
@@ -19923,10 +19957,23 @@ function validateServices(services) {
         process.exit(1);
       }
     }
-    validateStickySession(service);
+    validateLoadBalancing(service);
     validateFailoverConfig(service);
+    validateServiceTimeouts(service);
+    validateServiceHealthCheck(service);
   }
 }
+function validateServiceTimeouts(service) {
+  const t = service.timeouts;
+  if (!t)
+    return;
+  if (t.connect_ms !== undefined)
+    ensurePositiveNumber(t.connect_ms, "timeouts.connect_ms", `service "${service.name}"`);
+  if (t.send_ms !== undefined)
+    ensurePositiveNumber(t.send_ms, "timeouts.send_ms", `service "${service.name}"`);
+  if (t.read_ms !== undefined)
+    ensurePositiveNumber(t.read_ms, "timeouts.read_ms", `service "${service.name}"`);
+}
 function validateAndNormalizeConfig(config) {
   if (!config.routes || !Array.isArray(config.routes)) {
     logger.error('Error: "routes" is not defined or not an array in config.json.');
@@ -19959,9 +20006,6 @@ function validateAndNormalizeConfig(config) {
       validateAuthConfig(route.auth, `route "${route.path}"`);
     }
     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}"`);
     }