@owlmeans/route 0.1.18-rc.9 → 0.1.18

package/src/utils/route/types.ts

@@ -0,0 +1,35 @@
+import type { RouteAddress, RouteDeclaration, ResolvedServiceRoute } from '../../types.js'
+
+/**
+ * Where routes answer, worked out on demand against the context that asks — a declaration states
+ * only what it contributes and every address question walks the parent chain through the context.
+ */
+export interface RouteAddressHelper {
+  /**
+   * The declaration of the route's parent entrypoint, or `null` for a root route.
+   *
+   * @throws {SyntaxError} when the parent provides no route or the parent chain is a cycle
+   */
+  getParentRoute: (route: RouteDeclaration) => RouteDeclaration | null
+  /**
+   * Pick the service route this declaration answers on: the one it names, else the default of its
+   * app type, else the first of its app type.
+   *
+   * @throws {SyntaxError}
+   */
+  resolveService: (route: RouteDeclaration) => ResolvedServiceRoute
+  /**
+   * The full path: every ancestor's declared segment, then this one. Walks the parent chain through
+   * the context, so a declaration always states only what it contributes.
+   */
+  resolvePath: (route: RouteDeclaration) => string
+  /** `base` + the full path — what a server mounts and a client requests. */
+  resolveMount: (route: RouteDeclaration) => string
+  /**
+   * Where the route answers. A backend caller reaching a service over its INTERNAL host is inside the
+   * cluster, so that hop is never TLS.
+   */
+  resolveAddress: (route: RouteDeclaration) => RouteAddress
+  /** Does this route belong to the service the asking context IS? */
+  isLocalRoute: (route: RouteDeclaration) => boolean
+}

package/src/utils/route.ts

@@ -1,151 +1,111 @@
-import type { BasicConfig, BasicContext, Contextual } from '@owlmeans/context'
-import type { RouteAddress, RouteDeclaration, RouteModel, CommonServiceRoute, ResolvedServiceRoute } from '../types.js'
-import { isServiceRoute, isServiceRouteResolved } from './service.js'
+import { memoHelper } from '@owlmeans/context'
+import type { BasicContext } from '@owlmeans/context'
+import type { RouteAddress, RouteDeclaration, CommonServiceRoute, ResolvedServiceRoute } from '../types.js'
+import { serviceRouteHelper } from './service.js'
 import { normalizePath } from '../helper.js'
 import { RouteProtocols, SEP } from '../consts.js'
+import type { Config, RouteCarrier } from './types.local.js'
+import type { RouteAddressHelper } from './route/types.js'
 
-type Config = BasicConfig
+export const makeRouteAddressHelper = <C extends Config, T extends BasicContext<C>>(context: T): RouteAddressHelper => {
+  const { isServiceRoute, isServiceRouteResolved } = serviceRouteHelper
 
-/** What an entrypoint looks like from the route layer: something that carries a route model. */
-interface RouteCarrier extends Contextual {
-  _entrypoint: true
-  route: RouteModel
-}
+  const carrier = (alias: string): RouteCarrier =>
+    context.entrypoint<RouteCarrier>(alias)
 
-const carrier = <C extends Config, T extends BasicContext<C>>(context: T, alias: string): RouteCarrier =>
-  context.entrypoint<RouteCarrier>(alias)
+  const getParentRoute = (route: RouteDeclaration): RouteDeclaration | null => {
+    if (route.parent == null) {
+      return null
+    }
+    const parent = carrier(route.parent)
+    if (parent.route == null) {
+      throw new SyntaxError('Parent entrypoint doesn\'t provide a route')
+    }
+    assertCycle(route, parent.route.route)
 
-export const getParentRoute = <C extends Config, T extends BasicContext<C>>(
-  context: T, route: RouteDeclaration
-): RouteDeclaration | null => {
-  if (route.parent == null) {
-    return null
+    return parent.route.route
   }
-  const parent = carrier<C, T>(context, route.parent)
-  if (parent.route == null) {
-    throw new SyntaxError('Parent entrypoint doesn\'t provide a route')
-  }
-  assertCycle<C, T>(context, route, parent.route.route)
 
-  return parent.route.route
-}
+  const resolveService = (route: RouteDeclaration): ResolvedServiceRoute => {
+    if (context.cfg.services == null) {
+      throw new SyntaxError('Services aren\'t configured to resolve routes')
+    }
 
-export const overrideParams = (route: RouteDeclaration, overrides?: Partial<RouteDeclaration>, filter?: string[]) => {
-  Object.entries(overrides ?? {}).forEach(([key, value]) => {
-    if (route[key as keyof RouteDeclaration] == null
-      && (filter == null || filter.includes(key))) {
-      (route[key as keyof RouteDeclaration] as RouteDeclaration[keyof RouteDeclaration]) = value
+    const named = context.cfg.services[route.service ?? context.cfg.service]
+    if (named != null && !isServiceRoute(named)) {
+      throw new SyntaxError('Service is not a valid service route')
     }
-  })
-}
 
-/**
- * Pick the service route this declaration answers on: the one it names, else the default of its
- * app type, else the first of its app type.
- *
- * @throws {SyntaxError}
- */
-export const resolveService = <C extends Config, T extends BasicContext<C>>(
-  context: T, route: RouteDeclaration
-): ResolvedServiceRoute => {
-  if (context.cfg.services == null) {
-    throw new SyntaxError('Services aren\'t configured to resolve routes')
-  }
+    const service = named?.type === route.type ? named
+      : Object.values(context.cfg.services).find<CommonServiceRoute>(
+        (candidate): candidate is CommonServiceRoute => {
+          const _candidate = candidate as CommonServiceRoute
+          return _candidate.default === true && _candidate.type === route.type
+        }
+      ) ?? Object.values(context.cfg.services).find<CommonServiceRoute>(
+        (candidate): candidate is CommonServiceRoute => (candidate as CommonServiceRoute).type === route.type
+      )
+
+    if (!isServiceRoute(service)) {
+      throw new SyntaxError('Service is not a valid service route')
+    }
+    if (!isServiceRouteResolved(service)) {
+      throw new SyntaxError('Service route is not resolved')
+    }
 
-  const named = context.cfg.services[route.service ?? context.cfg.service]
-  if (named != null && !isServiceRoute(named)) {
-    throw new SyntaxError('Service is not a valid service route')
+    return service
   }
 
-  const service = named?.type === route.type ? named
-    : Object.values(context.cfg.services).find<CommonServiceRoute>(
-      (candidate): candidate is CommonServiceRoute => {
-        const _candidate = candidate as CommonServiceRoute
-        return _candidate.default === true && _candidate.type === route.type
-      }
-    ) ?? Object.values(context.cfg.services).find<CommonServiceRoute>(
-      (candidate): candidate is CommonServiceRoute => (candidate as CommonServiceRoute).type === route.type
-    )
+  const resolvePath = (route: RouteDeclaration): string => {
+    const parent = getParentRoute(route)
+    if (parent == null) {
+      return route.path
+    }
+    const parentPath = resolvePath(parent)
 
-  if (!isServiceRoute(service)) {
-    throw new SyntaxError('Service is not a valid service route')
-  }
-  if (!isServiceRouteResolved(service)) {
-    throw new SyntaxError('Service route is not resolved')
+    return (parentPath.startsWith(SEP) ? SEP : '')
+      + normalizePath(normalizePath(parentPath) + SEP + normalizePath(route.path))
   }
 
-  return service
-}
+  const resolveMount = (route: RouteDeclaration): string => {
+    const path = resolvePath(route)
+    const base = route.base ?? resolveService(route).base
 
-/**
- * The full path: every ancestor's declared segment, then this one. Walks the parent chain through
- * the context, so a declaration always states only what it contributes.
- */
-export const resolvePath = <C extends Config, T extends BasicContext<C>>(
-  context: T, route: RouteDeclaration
-): string => {
-  const parent = getParentRoute<C, T>(context, route)
-  if (parent == null) {
-    return route.path
+    return base != null && base.trim() !== ''
+      ? SEP + normalizePath(base) + SEP + normalizePath(path)
+      : path
   }
-  const parentPath = resolvePath<C, T>(context, parent)
-
-  return (parentPath.startsWith(SEP) ? SEP : '')
-    + normalizePath(normalizePath(parentPath) + SEP + normalizePath(route.path))
-}
-
-/** `base` + the full path — what a server mounts and a client requests. */
-export const resolveMount = <C extends Config, T extends BasicContext<C>>(
-  context: T, route: RouteDeclaration
-): string => {
-  const path = resolvePath<C, T>(context, route)
-  const base = route.base ?? resolveService<C, T>(context, route).base
-
-  return base != null && base.trim() !== ''
-    ? SEP + normalizePath(base) + SEP + normalizePath(path)
-    : path
-}
 
-/**
- * Where the route answers. A backend caller reaching a service over its INTERNAL host is inside the
- * cluster, so that hop is never TLS.
- */
-export const resolveAddress = <C extends Config, T extends BasicContext<C>>(
-  context: T, route: RouteDeclaration
-): RouteAddress => {
-  const service = resolveService<C, T>(context, route)
-  const host = route.host ?? service.host
-  const internalHost = route.internalHost ?? service.internalHost
-
-  return {
-    host,
-    port: route.port ?? service.port,
-    base: route.base ?? service.base,
-    secure: internalHost != null && internalHost === host ? false : route.secure ?? true,
-    protocol: route.protocol ?? RouteProtocols.WEB,
+  const resolveAddress = (route: RouteDeclaration): RouteAddress => {
+    const service = resolveService(route)
+    const host = route.host ?? service.host
+    const internalHost = route.internalHost ?? service.internalHost
+
+    return {
+      host,
+      port: route.port ?? service.port,
+      base: route.base ?? service.base,
+      secure: internalHost != null && internalHost === host ? false : route.secure ?? true,
+      protocol: route.protocol ?? RouteProtocols.WEB,
+    }
   }
-}
 
-/** Does this route belong to the service the asking context IS? */
-export const isLocalRoute = <C extends Config, T extends BasicContext<C>>(
-  context: T, route: RouteDeclaration
-): boolean => (route.service ?? context.cfg.service) === context.cfg.service
-
-/**
- * @throws {SyntaxError}
- */
-const assertCycle = <C extends BasicConfig, T extends BasicContext<C>>(
-  context: T, route: RouteDeclaration, parent: RouteDeclaration
-) => {
-  while (parent.parent != null) {
-    if (parent.parent === route.alias) {
-      throw new SyntaxError(`Route parentship cycle detected. Parent: ${parent.alias} has his child as ancestor ${route.alias}`)
+  const isLocalRoute = (route: RouteDeclaration): boolean =>
+    (route.service ?? context.cfg.service) === context.cfg.service
+
+  /**
+   * @throws {SyntaxError}
+   */
+  const assertCycle = (route: RouteDeclaration, parent: RouteDeclaration): void => {
+    while (parent.parent != null) {
+      if (parent.parent === route.alias) {
+        throw new SyntaxError(`Route parentship cycle detected. Parent: ${parent.alias} has his child as ancestor ${route.alias}`)
+      }
+      parent = carrier(parent.parent).route.route
     }
-    parent = carrier<C, T>(context, parent.parent).route.route
   }
+
+  return { getParentRoute, resolveService, resolvePath, resolveMount, resolveAddress, isLocalRoute }
 }
 
-export const prependBase = (route: RouteDeclaration, path: string) =>
-  route.base != null && route.base.trim() !== ''
-    ? SEP + normalizePath(route.base) + SEP + normalizePath(path)
-    : path
+export const routeAddressOf = memoHelper.oncePer(makeRouteAddressHelper)

package/src/utils/service/types.ts

@@ -0,0 +1,9 @@
+import type { CommonServiceRoute, ResolvedServiceRoute } from '../../types.js'
+
+/** Recognizes configured service routes. */
+export interface ServiceRouteHelper {
+  /** Whether a configured value is a service route: it names a service and a known app type. */
+  isServiceRoute: (obj?: Object) => obj is CommonServiceRoute
+  /** A service route is usable exactly when it knows the host it answers on. */
+  isServiceRouteResolved: (route: CommonServiceRoute) => route is ResolvedServiceRoute
+}

package/src/utils/service.ts

@@ -1,10 +1,16 @@
 import { AppType } from '@owlmeans/context'
 import type { ResolvedServiceRoute, CommonServiceRoute } from '../types.js'
+import type { ServiceRouteHelper } from './service/types.js'
 
-export const isServiceRoute = (obj?: Object): obj is CommonServiceRoute =>
-  obj != null && ('type' in obj) && ('service' in obj)
-  && (Object.values(AppType).includes(obj.type as AppType))
+export const createServiceRouteHelper = (): ServiceRouteHelper => {
+  const isServiceRoute = (obj?: Object): obj is CommonServiceRoute =>
+    obj != null && ('type' in obj) && ('service' in obj)
+    && (Object.values(AppType).includes(obj.type as AppType))
 
-/** A service route is usable exactly when it knows the host it answers on. */
-export const isServiceRouteResolved = (route: CommonServiceRoute): route is ResolvedServiceRoute =>
-  route.host != null && route.host.trim() !== ''
+  const isServiceRouteResolved = (route: CommonServiceRoute): route is ResolvedServiceRoute =>
+    route.host != null && route.host.trim() !== ''
+
+  return { isServiceRoute, isServiceRouteResolved }
+}
+
+export const serviceRouteHelper = createServiceRouteHelper()

package/src/utils/types.local.ts

@@ -0,0 +1,10 @@
+import type { BasicConfig, Contextual } from '@owlmeans/context'
+import type { RouteModel } from '../types.js'
+
+export type Config = BasicConfig
+
+/** What an entrypoint looks like from the route layer: something that carries a route model. */
+export interface RouteCarrier extends Contextual {
+  _entrypoint: true
+  route: RouteModel
+}