@rip-lang/server 1.3.114 → 1.3.116

package/edge/upstream.rip

@@ -0,0 +1,272 @@
+# ==============================================================================
+# edge/upstream.rip — upstream pools, health checks, and retry helpers
+# ==============================================================================
+
+DEFAULT_HEALTH =
+  path: '/health'
+  intervalMs: 5000
+  timeoutMs: 2000
+  unhealthyThreshold: 3
+  healthyThreshold: 1
+
+DEFAULT_RETRY =
+  attempts: 2
+  retryOn: [502, 503, 504]
+  retryMethods: ['GET', 'HEAD', 'OPTIONS']
+  backoffMs: 100
+
+DEFAULT_CIRCUIT =
+  errorThreshold: 0.5
+  minRequests: 10
+  cooldownMs: 30000
+  jitterRatio: 0.3
+
+toArray = (value, fallback = []) ->
+  if Array.isArray(value) then value else fallback
+
+toPositiveInt = (value, fallback) ->
+  return fallback unless value?
+  n = parseInt(String(value))
+  if Number.isFinite(n) and n >= 0 then n else fallback
+
+toPositiveFloat = (value, fallback) ->
+  return fallback unless value?
+  n = parseFloat(String(value))
+  if Number.isFinite(n) and n >= 0 then n else fallback
+
+mergeHealth = (config = {}) ->
+  path: if typeof config.path is 'string' and config.path.startsWith('/') then config.path else DEFAULT_HEALTH.path
+  intervalMs: toPositiveInt(config.intervalMs, DEFAULT_HEALTH.intervalMs)
+  timeoutMs: toPositiveInt(config.timeoutMs, DEFAULT_HEALTH.timeoutMs)
+  unhealthyThreshold: Math.max(1, toPositiveInt(config.unhealthyThreshold, DEFAULT_HEALTH.unhealthyThreshold))
+  healthyThreshold: Math.max(1, toPositiveInt(config.healthyThreshold, DEFAULT_HEALTH.healthyThreshold))
+
+mergeRetry = (config = {}) ->
+  attempts: Math.max(1, toPositiveInt(config.attempts, DEFAULT_RETRY.attempts))
+  retryOn: toArray(config.retryOn, DEFAULT_RETRY.retryOn).map((n) -> parseInt(String(n))).filter(Number.isFinite)
+  retryMethods: toArray(config.retryMethods, DEFAULT_RETRY.retryMethods).map((m) -> String(m).toUpperCase())
+  backoffMs: toPositiveInt(config.backoffMs, DEFAULT_RETRY.backoffMs)
+
+mergeCircuit = (config = {}) ->
+  errorThreshold: Math.min(1, Math.max(0, toPositiveFloat(config.errorThreshold, DEFAULT_CIRCUIT.errorThreshold)))
+  minRequests: Math.max(1, toPositiveInt(config.minRequests, DEFAULT_CIRCUIT.minRequests))
+  cooldownMs: Math.max(1, toPositiveInt(config.cooldownMs, DEFAULT_CIRCUIT.cooldownMs))
+  jitterRatio: Math.min(1, Math.max(0, toPositiveFloat(config.jitterRatio, DEFAULT_CIRCUIT.jitterRatio)))
+
+createHistory = ->
+  []
+
+trimHistory = (history, minRequests) ->
+  history.shift() while history.length > minRequests
+  history
+
+recordCircuitResult = (target, success, pool = null) ->
+  target.history.push(success)
+  trimHistory(target.history, target.circuitConfig.minRequests)
+
+  return unless target.circuitState is 'closed'
+  return unless target.history.length >= target.circuitConfig.minRequests
+  failures = target.history.filter((ok) -> not ok).length
+  errorRate = failures / target.history.length
+  openCircuit(target, pool?.randomFn or Math.random, pool?.nowFn or Date.now) if errorRate >= target.circuitConfig.errorThreshold
+
+computeCooldownMs = (target, randomFn = Math.random) ->
+  base = target.circuitConfig.cooldownMs
+  jitter = base * target.circuitConfig.jitterRatio * randomFn()
+  Math.round(base + jitter)
+
+openCircuit = (target, randomFn = Math.random, nowFn = Date.now) ->
+  target.circuitState = 'open'
+  target.circuitOpenedAt = nowFn()
+  target.circuitProbeInFlight = false
+  target.circuitCooldownMs = computeCooldownMs(target, randomFn)
+
+export createUpstreamPool = (options = {}) ->
+  upstreams: new Map()
+  intervals: new Map()
+  fetchFn: options.fetchFn or fetch
+  nowFn: options.nowFn or Date.now
+  randomFn: options.randomFn or Math.random
+  setIntervalFn: options.setIntervalFn or setInterval
+  clearIntervalFn: options.clearIntervalFn or clearInterval
+
+export normalizeUpstream = (id, config = {}) ->
+  timeouts =
+    connectMs: toPositiveInt(config.timeouts?.connectMs or config.timeout?.connectMs, 2000)
+    readMs: toPositiveInt(config.timeouts?.readMs or config.timeout?.readMs, 30000)
+  targets = toArray(config.targets).map (url, idx) ->
+    url: url
+    targetId: "#{id}:#{idx}"
+    healthy: true
+    inflight: 0
+    lastCheckAt: null
+    lastStatus: null
+    consecutiveFailures: 0
+    consecutiveSuccesses: 0
+    latencyEwma: 0
+    history: createHistory()
+    circuitState: 'closed'
+    circuitOpenedAt: null
+    circuitCooldownMs: null
+    circuitProbeInFlight: false
+    health: mergeHealth(config.healthCheck)
+    retry: mergeRetry(config.retry)
+    timeouts: timeouts
+    circuitConfig: mergeCircuit(config.circuit)
+    meta: config.meta or {}
+  {
+    id
+    healthCheck: mergeHealth(config.healthCheck)
+    retry: mergeRetry(config.retry)
+    timeouts: timeouts
+    circuit: mergeCircuit(config.circuit)
+    targets
+    strategy: config.strategy or 'least-inflight'
+    meta: config.meta or {}
+  }
+
+export addUpstream = (pool, id, config = {}) ->
+  upstream = normalizeUpstream(id, config)
+  pool.upstreams.set(id, upstream)
+  upstream
+
+export getUpstream = (pool, id) ->
+  pool.upstreams.get(id) ?? null
+
+export removeUpstream = (pool, id) ->
+  stopHealthCheck(pool, id)
+  pool.upstreams.delete(id)
+
+export listUpstreams = (pool) ->
+  Array.from(pool.upstreams.values())
+
+export selectTarget = (upstream, nowFn = Date.now) ->
+  return null unless upstream?.targets?.length
+  candidates = upstream.targets.filter (target) ->
+    return false unless target.healthy
+    if target.circuitState is 'open'
+      cooldown = target.circuitCooldownMs or target.circuitConfig.cooldownMs
+      if target.circuitOpenedAt? and nowFn() - target.circuitOpenedAt >= cooldown
+        target.circuitState = 'half-open'
+        target.circuitProbeInFlight = false
+      else
+        return false
+    if target.circuitState is 'half-open'
+      return false if target.circuitProbeInFlight
+    true
+  return null unless candidates.length
+  best = candidates[0]
+  for candidate in candidates[1..]
+    better = false
+    if candidate.inflight < best.inflight
+      better = true
+    else if candidate.inflight is best.inflight and candidate.latencyEwma < best.latencyEwma
+      better = true
+    else if candidate.inflight is best.inflight and candidate.latencyEwma is best.latencyEwma and candidate.targetId < best.targetId
+      better = true
+    best = candidate if better
+  best
+
+export markTargetBusy = (target) ->
+  target.inflight++
+  target.circuitProbeInFlight = true if target.circuitState is 'half-open'
+  target
+
+export releaseTarget = (target, latencyMs = 0, success = true, pool = null) ->
+  target.inflight = Math.max(0, target.inflight - 1)
+  target.latencyEwma = if target.latencyEwma > 0 then (target.latencyEwma * 0.8) + (latencyMs * 0.2) else latencyMs
+  target.circuitProbeInFlight = false if target.circuitState is 'half-open'
+
+  if success
+    if target.circuitState is 'half-open'
+      target.circuitState = 'closed'
+      target.circuitOpenedAt = null
+      target.circuitCooldownMs = null
+      target.history.length = 0
+    recordCircuitResult(target, true, pool)
+  else
+    if target.circuitState is 'half-open'
+      openCircuit(target, pool?.randomFn or Math.random, pool?.nowFn or Date.now)
+    else
+      recordCircuitResult(target, false, pool)
+  target
+
+export shouldRetry = (retryConfig, method, status, bodyStarted = false) ->
+  return false if bodyStarted
+  cfg = mergeRetry(retryConfig)
+  return false unless cfg.retryMethods.includes(String(method or 'GET').toUpperCase())
+  cfg.retryOn.includes(status)
+
+export computeRetryDelayMs = (retryConfig, attempt, randomFn = Math.random) ->
+  cfg = mergeRetry(retryConfig)
+  base = cfg.backoffMs * Math.max(1, attempt)
+  jitter = cfg.backoffMs * 0.3 * randomFn()
+  Math.round(base + jitter)
+
+export updateTargetHealth = (target, healthy, pool = null) ->
+  target.lastCheckAt = (pool?.nowFn or Date.now)()
+  if healthy
+    target.consecutiveFailures = 0
+    target.consecutiveSuccesses++
+    if not target.healthy and target.consecutiveSuccesses >= target.health.healthyThreshold
+      target.healthy = true
+    if target.circuitState in ['open', 'half-open']
+      target.circuitState = 'closed'
+      target.circuitOpenedAt = null
+      target.circuitCooldownMs = null
+      target.circuitProbeInFlight = false
+      target.history.length = 0
+  else
+    target.consecutiveSuccesses = 0
+    target.consecutiveFailures++
+    if target.healthy and target.consecutiveFailures >= target.health.unhealthyThreshold
+      target.healthy = false
+    openCircuit(target, pool?.randomFn or Math.random, pool?.nowFn or Date.now) if target.circuitState is 'half-open'
+  target
+
+export checkTargetHealth = (pool, target, fetchFn = null) ->
+  runFetch = fetchFn or pool.fetchFn or fetch
+  url = target.url + target.health.path
+  try
+    res = runFetch(url)
+    res = res! if res?.then
+    target.lastStatus = res.status
+    updateTargetHealth(target, res.ok, pool)
+    res.ok
+  catch
+    target.lastStatus = null
+    updateTargetHealth(target, false, pool)
+    false
+
+export startHealthCheck = (pool, upstreamId) ->
+  upstream = getUpstream(pool, upstreamId)
+  return null unless upstream
+  stopHealthCheck(pool, upstreamId)
+
+  targets = upstream.targets
+  return null unless targets.length > 0
+  intervalMs = upstream.healthCheck.intervalMs
+  offsetMs = if targets.length > 0 then Math.floor(intervalMs / targets.length) else 0
+
+  timers = targets.map (target, idx) ->
+    checkTargetHealth(pool, target)
+    pool.setIntervalFn((-> checkTargetHealth(pool, target)), intervalMs + (idx * offsetMs))
+
+  pool.intervals.set(upstreamId, timers)
+  timers
+
+export startHealthChecks = (pool) ->
+  for upstream in listUpstreams(pool)
+    startHealthCheck(pool, upstream.id)
+  pool
+
+export stopHealthCheck = (pool, upstreamId) ->
+  timers = pool.intervals.get(upstreamId)
+  if timers
+    pool.clearIntervalFn(timer) for timer in timers
+    pool.intervals.delete(upstreamId)
+
+export stopHealthChecks = (pool) ->
+  for upstreamId in pool.intervals.keys()
+    stopHealthCheck(pool, upstreamId)
+  pool

package/edge/verify.rip

@@ -0,0 +1,73 @@
+# ==============================================================================
+# edge/verify.rip — edge runtime verification helpers
+# ==============================================================================
+
+export buildVerificationResult = (ok, code = null, message = null, details = null) ->
+  { ok, code, message, details }
+
+defaultPolicy =
+  requireHealthyUpstreams: true
+  requireReadyApps: true
+  includeUnroutedManagedApps: true
+  minHealthyTargetsPerUpstream: 1
+
+mergePolicy = (policy = {}) ->
+  requireHealthyUpstreams: if policy.requireHealthyUpstreams? then policy.requireHealthyUpstreams is true else defaultPolicy.requireHealthyUpstreams
+  requireReadyApps: if policy.requireReadyApps? then policy.requireReadyApps is true else defaultPolicy.requireReadyApps
+  includeUnroutedManagedApps: if policy.includeUnroutedManagedApps? then policy.includeUnroutedManagedApps is true else defaultPolicy.includeUnroutedManagedApps
+  minHealthyTargetsPerUpstream: Math.max(1, parseInt(String(policy.minHealthyTargetsPerUpstream or defaultPolicy.minHealthyTargetsPerUpstream)) or 1)
+
+export collectRouteRequirements = (routeTable, appRegistry = null, defaultAppId = null, policy = {}) ->
+  policy = mergePolicy(policy)
+  upstreamIds = new Set()
+  appIds = new Set()
+
+  for route in (routeTable?.routes or [])
+    upstreamIds.add(route.upstream) if route.upstream
+    appIds.add(route.app) if route.app
+
+  if appRegistry and policy.includeUnroutedManagedApps
+    for [appId, app] as appRegistry.apps
+      continue if appId is defaultAppId
+      continue unless app?.config?.entry
+      appIds.add(appId)
+
+  {
+    upstreamIds: Array.from(upstreamIds)
+    appIds: Array.from(appIds)
+  }
+
+export verifyRouteRuntime = (runtime, appRegistry, defaultAppId, getUpstreamFn, checkTargetHealthFn, getAppStateFn, policy = {}) ->
+  policy = mergePolicy(policy)
+  requirements = collectRouteRequirements(runtime?.routeTable, appRegistry, defaultAppId, policy)
+
+  if policy.requireHealthyUpstreams
+    for upstreamId in requirements.upstreamIds
+      upstream = getUpstreamFn(runtime.upstreamPool, upstreamId)
+      return buildVerificationResult(false, 'upstream_missing', "Referenced upstream #{upstreamId} is missing", { upstreamId }) unless upstream
+
+      healthyTargets = []
+      for target in upstream.targets
+        healthyTargets.push(target.targetId) if checkTargetHealthFn(runtime.upstreamPool, target)
+
+      unless healthyTargets.length >= policy.minHealthyTargetsPerUpstream
+        return buildVerificationResult(
+          false
+          'upstream_no_healthy_targets'
+          "Upstream #{upstreamId} has too few healthy targets after activation"
+          { upstreamId, targetCount: upstream.targets.length, healthyTargets: healthyTargets.length, requiredHealthyTargets: policy.minHealthyTargetsPerUpstream }
+        )
+
+  if policy.requireReadyApps
+    for appId in requirements.appIds
+      app = getAppStateFn(appRegistry, appId)
+      return buildVerificationResult(false, 'app_missing', "Referenced app #{appId} is missing", { appId }) unless app
+      unless app.sockets?.length > 0
+        return buildVerificationResult(
+          false
+          'app_no_ready_workers'
+          "App #{appId} has no ready workers after activation"
+          { appId, workers: app.sockets?.length or 0 }
+        )
+
+  buildVerificationResult(true)

package/middleware.rip

@@ -217,7 +217,7 @@ export compress = (opts = {}) ->
 #   before ->
 #     session.userId = 123
 #
-#   get '/profile', ->
+#   get '/profile' ->
 #     { userId: session.userId }
 #
 # Security:
@@ -488,8 +488,8 @@ export serve = (opts = {}) ->
   prefix        = opts.app or ''
   appDir        = opts.dir or '.'
   routesDir     = "#{appDir}/#{opts.routes or 'routes'}"
-  rawBundle = opts.bundle or opts.components or ['components']
-  bundles = new Map()
+  rawBundle     = opts.bundle or opts.components or ['components']
+  bundles       = new Map()
   if Array.isArray(rawBundle)
     bundles.set 'bundle', rawBundle.map (d) -> "#{appDir}/#{d}"
   else if typeof rawBundle is 'object'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rip-lang/server",
-  "version": "1.3.114",
+  "version": "1.3.116",
   "description": "Pure Rip web framework and application server",
   "type": "module",
   "main": "api.rip",
@@ -45,7 +45,7 @@
   "author": "Steve Shreeve <steve.shreeve@gmail.com>",
   "license": "MIT",
   "dependencies": {
-    "rip-lang": ">=3.13.119"
+    "rip-lang": ">=3.13.121"
   },
   "files": [
     "api.rip",