@travetto/web 7.0.0-rc.1 → 7.0.0-rc.3

package/src/registry/visitor.ts

@@ -28,12 +28,12 @@ export class ControllerVisitUtil {
 
     await visitor.onControllerStart?.(controller);
     for (const endpoint of controller.endpoints) {
-      const endpointSchema = SchemaRegistryIndex.getMethodConfig(cls, endpoint.methodName);
+      const endpointSchema = SchemaRegistryIndex.get(cls).getMethod(endpoint.methodName);
       if (endpointSchema.private === true && options.skipPrivate) {
         continue;
       }
 
-      const { parameters: params, returnType } = SchemaRegistryIndex.getMethodConfig(cls, endpoint.methodName);
+      const { parameters: params, returnType } = endpointSchema;
       await visitor.onEndpointStart?.(endpoint, controller, params);
       if (returnType) {
         await this.#onSchemaEvent(visitor, returnType.type);

package/src/router/base.ts

@@ -20,18 +20,18 @@ export abstract class BaseWebRouter implements WebRouter {
   #cleanup = new Map<string, Function>();
   #interceptors: WebInterceptor[];
 
-  async #register(c: Class): Promise<void> {
-    const config = ControllerRegistryIndex.getConfig(c);
+  async #register(cls: Class): Promise<void> {
+    const config = ControllerRegistryIndex.getConfig(cls);
 
-    let endpoints = await EndpointUtil.getBoundEndpoints(c);
+    let endpoints = await EndpointUtil.getBoundEndpoints(cls);
     endpoints = EndpointUtil.orderEndpoints(endpoints);
 
-    for (const ep of endpoints) {
-      ep.filter = EndpointUtil.createEndpointHandler(this.#interceptors, ep, config);
+    for (const endpoint of endpoints) {
+      endpoint.filter = EndpointUtil.createEndpointHandler(this.#interceptors, endpoint, config);
     }
 
     const fn = await this.register(endpoints, config);
-    this.#cleanup.set(c.Ⲑid, fn);
+    this.#cleanup.set(cls.Ⲑid, fn);
   };
 
   /**
@@ -41,25 +41,25 @@ export abstract class BaseWebRouter implements WebRouter {
 
     this.#interceptors = await DependencyRegistryIndex.getInstances(toConcrete<WebInterceptor>());
     this.#interceptors = EndpointUtil.orderInterceptors(this.#interceptors);
-    const names = this.#interceptors.map(x => x.constructor.name);
+    const names = this.#interceptors.map(interceptor => interceptor.constructor.name);
     console.debug('Sorting interceptors', { count: names.length, names });
 
     // Register all active
-    for (const c of ControllerRegistryIndex.getClasses()) {
-      await this.#register(c);
+    for (const cls of ControllerRegistryIndex.getClasses()) {
+      await this.#register(cls);
     }
 
     // Listen for updates
-    Registry.onClassChange(async e => {
-      const targetCls = 'curr' in e ? e.curr : e.prev;
-      console.debug('Registry event', { type: e.type, target: targetCls.Ⲑid });
+    Registry.onClassChange(async event => {
+      const targetCls = 'current' in event ? event.current : event.previous;
+      console.debug('Registry event', { type: event.type, target: targetCls.Ⲑid });
 
-      if ('prev' in e) {
-        this.#cleanup.get(e.prev.Ⲑid)?.();
-        this.#cleanup.delete(e.prev.Ⲑid);
+      if ('previous' in event) {
+        this.#cleanup.get(event.previous.Ⲑid)?.();
+        this.#cleanup.delete(event.previous.Ⲑid);
       }
-      if ('curr' in e) {
-        await this.#register(e.curr);
+      if ('current' in event) {
+        await this.#register(event.current);
       }
     }, ControllerRegistryIndex);
   }

package/src/router/standard.ts

@@ -27,16 +27,16 @@ export class StandardWebRouter extends BaseWebRouter {
   raw = router();
 
   async register(endpoints: EndpointConfig[]): Promise<() => void> {
-    for (const ep of endpoints) {
-      const fullPath = ep.fullPath.replace(/[*][^*]+/g, '*'); // Flatten wildcards
+    for (const endpoint of endpoints) {
+      const fullPath = endpoint.fullPath.replace(/[*][^*]+/g, '*'); // Flatten wildcards
       const handler = (): void => { };
-      this.#cache.set(handler, ep);
-      this.raw[HTTP_METHODS[ep.httpMethod ?? DEFAULT_HTTP_METHOD].lower](fullPath, handler);
+      this.#cache.set(handler, endpoint);
+      this.raw[HTTP_METHODS[endpoint.httpMethod ?? DEFAULT_HTTP_METHOD].lower](fullPath, handler);
     }
 
     return (): void => {
-      for (const ep of endpoints ?? []) {
-        this.raw.off(ep.httpMethod ?? DEFAULT_HTTP_METHOD, ep.fullPath);
+      for (const endpoint of endpoints ?? []) {
+        this.raw.off(endpoint.httpMethod ?? DEFAULT_HTTP_METHOD, endpoint.fullPath);
       }
     };
   }

package/src/types/core.ts

@@ -3,8 +3,8 @@ function verb<
   M extends string,
   L extends string,
   C extends Partial<MethodConfig>
->(method: M, lower: L, cfg: C): { method: M, lower: L } & C & MethodConfig {
-  return { body: false, cacheable: false, emptyStatusCode: 204, ...cfg, method, lower, };
+>(method: M, lower: L, config: C): { method: M, lower: L } & C & MethodConfig {
+  return { body: false, cacheable: false, emptyStatusCode: 204, ...config, method, lower, };
 }
 
 export const HTTP_METHODS = {

package/src/types/headers.ts

@@ -9,14 +9,14 @@ export type WebHeadersInit = Headers | Record<string, undefined | null | HeaderV
  */
 export class WebHeaders extends Headers {
 
-  constructor(o?: WebHeadersInit) {
-    const passed = (o instanceof Headers);
-    super(passed ? o : undefined);
+  constructor(input?: WebHeadersInit) {
+    const passed = (input instanceof Headers);
+    super(passed ? input : undefined);
 
-    if (o && !passed) {
-      for (const [k, v] of (Array.isArray(o) ? o : Object.entries(o))) {
-        if (v !== undefined && v !== null && !k.startsWith(':')) {
-          this.append(k, castTo(v));
+    if (input && !passed) {
+      for (const [key, value] of (Array.isArray(input) ? input : Object.entries(input))) {
+        if (value !== undefined && value !== null && !key.startsWith(':')) {
+          this.append(key, castTo(value));
         }
       }
     }
@@ -33,21 +33,21 @@ export class WebHeaders extends Headers {
    * Get a header value as a list, breaking on commas except for cookies
    */
   getList(key: string): string[] | undefined {
-    const v = this.get(key);
-    if (!v) {
+    const value = this.get(key);
+    if (!value) {
       return;
-    } else if (v.toLowerCase() === 'set-cookie') {
+    } else if (value.toLowerCase() === 'set-cookie') {
       return this.getSetCookie();
     }
-    return v.split(key === 'cookie' ? /\s{0,3};\s{0,3}/ : /\s{0,3},\s{0,3}/);
+    return value.split(key === 'cookie' ? /\s{0,3};\s{0,3}/ : /\s{0,3},\s{0,3}/);
   }
 
   // @ts-expect-error
-  forEach(set: (v: string | string[], k: string, headers: WebHeaders) => void): void;
-  forEach(set: (v: Any, k: string, headers: WebHeaders) => void): void;
-  forEach(set: (v: string | string[], k: string, headers: WebHeaders) => void): void {
-    for (const [k, v] of this.entries()) {
-      set(k === 'set-cookie' ? this.getSetCookie() : v, k, this);
+  forEach(set: (value: string | string[], key: string, headers: WebHeaders) => void): void;
+  forEach(set: (value: Any, key: string, headers: WebHeaders) => void): void;
+  forEach(set: (value: string | string[], key: string, headers: WebHeaders) => void): void {
+    for (const [key, value] of this.entries()) {
+      set(key === 'set-cookie' ? this.getSetCookie() : value, key, this);
     }
   }
 

package/src/types/message.ts

@@ -25,9 +25,9 @@ export class BaseWebMessage<B = unknown, C = unknown> implements WebMessage<B, C
   readonly headers: WebHeaders;
   body?: B;
 
-  constructor(o: WebMessageInit<B, C> = {}) {
-    this.context = o.context ?? castTo<C>({});
-    this.headers = new WebHeaders(o.headers);
-    this.body = o.body;
+  constructor(input: WebMessageInit<B, C> = {}) {
+    this.context = input.context ?? castTo<C>({});
+    this.headers = new WebHeaders(input.headers);
+    this.body = input.body;
   }
 }

package/src/util/body.ts

@@ -19,13 +19,13 @@ export class WebBodyUtil {
    */
   static async * buildMultiPartBody(form: FormData, boundary: string): AsyncIterable<string | Buffer> {
     const nl = '\r\n';
-    for (const [k, v] of form.entries()) {
-      const data = v.slice();
+    for (const [key, value] of form.entries()) {
+      const data = value.slice();
       const filename = data instanceof File ? data.name : undefined;
       const size = data instanceof Blob ? data.size : data.length;
       const type = data instanceof Blob ? data.type : undefined;
       yield `--${boundary}${nl}`;
-      yield `Content-Disposition: form-data; name="${k}"; filename="${filename ?? k}"${nl}`;
+      yield `Content-Disposition: form-data; name="${key}"; filename="${filename ?? key}"${nl}`;
       yield `Content-Length: ${size}${nl}`;
       if (type) {
         yield `Content-Type: ${type}${nl}`;
@@ -66,7 +66,7 @@ export class WebBodyUtil {
       toAdd.push(['Content-disposition', `attachment; filename="${value.name}"`]);
     }
 
-    return toAdd.filter((x): x is [string, string] => !!x[1]);
+    return toAdd.filter((pair): pair is [string, string] => !!pair[1]);
   }
 
   /**
@@ -97,8 +97,8 @@ export class WebBodyUtil {
 
     const out: Omit<WebMessage<WebBinaryBody>, 'context'> = { headers: new WebHeaders(message.headers), body: null! };
     if (body instanceof Blob) {
-      for (const [k, v] of this.getBlobHeaders(body)) {
-        out.headers.set(k, v);
+      for (const [key, value] of this.getBlobHeaders(body)) {
+        out.headers.set(key, value);
       }
       out.body = Readable.fromWeb(body.stream());
     } else if (body instanceof FormData) {
@@ -139,29 +139,29 @@ export class WebBodyUtil {
   /**
    * Set body and mark as unprocessed
    */
-  static markRaw(val: WebBinaryBody | undefined): typeof val {
-    if (val) {
-      Object.defineProperty(val, WebRawStreamSymbol, { value: val });
+  static markRaw(body: WebBinaryBody | undefined): typeof body {
+    if (body) {
+      Object.defineProperty(body, WebRawStreamSymbol, { value: body });
     }
-    return val;
+    return body;
   }
 
   /**
    * Is the input raw
    */
-  static isRaw(val: unknown): val is WebBinaryBody {
+  static isRaw(body: unknown): body is WebBinaryBody {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return !!val && ((Buffer.isBuffer(val) || BinaryUtil.isReadable(val)) && (val as Any)[WebRawStreamSymbol] === val);
+    return !!body && ((Buffer.isBuffer(body) || BinaryUtil.isReadable(body)) && (body as Any)[WebRawStreamSymbol] === body);
   }
 
   /**
    * Simple parse support
    */
-  static parseBody(type: string, val: string): unknown {
+  static parseBody(type: string, body: string): unknown {
     switch (type) {
-      case 'text': return val;
-      case 'json': return JSON.parse(val);
-      case 'form': return Object.fromEntries(new URLSearchParams(val));
+      case 'text': return body;
+      case 'json': return JSON.parse(body);
+      case 'form': return Object.fromEntries(new URLSearchParams(body));
     }
   }
 
@@ -199,11 +199,11 @@ export class WebBodyUtil {
       }
       all.push(decoder.decode(Buffer.alloc(0), { stream: false }));
       return { text: all.join(''), read: received };
-    } catch (err) {
-      if (err instanceof Error && err.name === 'AbortError') {
+    } catch (error) {
+      if (error instanceof Error && error.name === 'AbortError') {
         throw WebError.for('Request Aborted', 400, { received });
       } else {
-        throw err;
+        throw error;
       }
     }
   }

package/src/util/common.ts

@@ -38,18 +38,18 @@ export class WebCommonUtil {
   }
 
   static #buildEdgeMap<T, U extends OrderedState<T>>(items: List<U>): Map<T, Set<T>> {
-    const edgeMap = new Map(items.map(x => [x.key, new Set(x.after ?? [])]));
+    const edgeMap = new Map(items.map(item => [item.key, new Set(item.after ?? [])]));
 
     // Build out edge map
     for (const input of items) {
-      for (const bf of input.before ?? []) {
-        if (edgeMap.has(bf)) {
-          edgeMap.get(bf)!.add(input.key);
+      for (const item of input.before ?? []) {
+        if (edgeMap.has(item)) {
+          edgeMap.get(item)!.add(input.key);
         }
       }
       const afterSet = edgeMap.get(input.key)!;
-      for (const el of input.after ?? []) {
-        afterSet.add(el);
+      for (const item of input.after ?? []) {
+        afterSet.add(item);
       }
     }
     return edgeMap;
@@ -64,7 +64,7 @@ export class WebCommonUtil {
       rules,
       this.#convert.bind(this),
       (regex, mime) => regex.test(mime),
-      k => k
+      key => key
     );
   }
 
@@ -94,8 +94,8 @@ export class WebCommonUtil {
       }
     }
 
-    const inputMap = new Map(items.map(x => [x.key, x]));
-    return keys.map(k => inputMap.get(k)!);
+    const inputMap = new Map(items.map(item => [item.key, item]));
+    return keys.map(key => inputMap.get(key)!);
   }
 
   /**
@@ -110,18 +110,18 @@ export class WebCommonUtil {
   /**
    * From catch value
    */
-  static catchResponse(err: unknown): WebResponse<Error> {
-    if (err instanceof WebResponse) {
-      return err;
+  static catchResponse(error: unknown): WebResponse<Error> {
+    if (error instanceof WebResponse) {
+      return error;
     }
 
-    const body = err instanceof Error ? err :
-      (!!err && typeof err === 'object' && ('message' in err && typeof err.message === 'string')) ?
-        new AppError(err.message, { details: err }) :
-        new AppError(`${err}`);
+    const body = error instanceof Error ? error :
+      (!!error && typeof error === 'object' && ('message' in error && typeof error.message === 'string')) ?
+        new AppError(error.message, { details: error }) :
+        new AppError(`${error}`);
 
-    const error: Error & Partial<WebError> = body;
-    const statusCode = error.details?.statusCode ?? ERROR_CATEGORY_STATUS[error.category!] ?? 500;
+    const webError: Error & Partial<WebError> = body;
+    const statusCode = webError.details?.statusCode ?? ERROR_CATEGORY_STATUS[webError.category!] ?? 500;
 
     return new WebResponse({ body, context: { httpStatusCode: statusCode } });
   }
@@ -147,7 +147,7 @@ export class WebCommonUtil {
     if (typeof input === 'number') {
       return input;
     }
-    const [, num, unit] = input.toLowerCase().split(/(\d+)/);
-    return parseInt(num, 10) * (UNIT_MAPPING[unit] ?? 1);
+    const [, value, unit] = input.toLowerCase().split(/(\d+)/);
+    return parseInt(value, 10) * (UNIT_MAPPING[unit] ?? 1);
   }
 }

package/src/util/cookie.ts

@@ -4,8 +4,8 @@ import { Cookie, CookieGetOptions, CookieSetOptions } from '../types/cookie.ts';
 import { KeyGrip } from './keygrip.ts';
 import { WebHeaderUtil } from './header.ts';
 
-const pairText = (c: Cookie): string => `${c.name}=${c.value}`;
-const pair = (k: string, v: unknown): string => `${k}=${v}`;
+const pairText = (cookie: Cookie): string => `${cookie.name}=${cookie.value}`;
+const pair = (key: string, value: unknown): string => `${key}=${value}`;
 
 type CookieJarOptions = { keys?: string[] } & CookieSetOptions;
 
@@ -66,13 +66,13 @@ export class CookieJar {
     return this;
   }
 
-  has(name: string, opts: CookieGetOptions = {}): boolean {
-    const needSigned = opts.signed ?? this.#setOptions.signed;
+  has(name: string, options: CookieGetOptions = {}): boolean {
+    const needSigned = options.signed ?? this.#setOptions.signed;
     return name in this.#cookies && this.#cookies[name].signed === needSigned;
   }
 
-  get(name: string, opts: CookieGetOptions = {}): string | undefined {
-    if (this.has(name, opts)) {
+  get(name: string, options: CookieGetOptions = {}): string | undefined {
+    if (this.has(name, options)) {
       return this.#cookies[name]?.value;
     }
   }
@@ -111,12 +111,12 @@ export class CookieJar {
   }
 
   exportCookieHeader(): string {
-    return this.getAll().flatMap(c => this.#exportCookie(c)).join('; ');
+    return this.getAll().flatMap(cookie => this.#exportCookie(cookie)).join('; ');
   }
 
   exportSetCookieHeader(): string[] {
     return this.getAll()
-      .filter(x => x.response)
-      .flatMap(c => this.#exportCookie(c, true));
+      .filter(cookie => cookie.response)
+      .flatMap(cookie => this.#exportCookie(cookie, true));
   }
 }

package/src/util/endpoint.ts

@@ -65,12 +65,12 @@ export class EndpointUtil {
 
     const inputByClass = Map.groupBy(
       [...controller?.interceptorConfigs ?? [], ...endpoint.interceptorConfigs ?? []],
-      x => x[0]
+      entry => entry[0]
     );
 
     const configs = new Map<Class, unknown>(interceptors.map(inst => {
       const cls = asConstructable<WebInterceptor>(inst).constructor;
-      const inputs = (inputByClass.get(cls) ?? []).map(x => x[1]);
+      const inputs = (inputByClass.get(cls) ?? []).map(entry => entry[1]);
       const config = Object.assign({}, inst.config, ...inputs);
       return [cls, inst.finalizeConfig?.({ config, endpoint }, castTo(inputs)) ?? config];
     }));
@@ -96,8 +96,8 @@ export class EndpointUtil {
       case 'header': return isArray ? request.headers.getList(name) : request.headers.get(name);
       case 'query': {
         const withQuery: typeof request & { [WebQueryExpandedSymbol]?: Record<string, unknown> } = request;
-        const q = withQuery[WebQueryExpandedSymbol] ??= BindUtil.expandPaths(request.context.httpQuery ?? {});
-        return q[name];
+        const query = withQuery[WebQueryExpandedSymbol] ??= BindUtil.expandPaths(request.context.httpQuery ?? {});
+        return query[name];
       }
     }
   }
@@ -114,38 +114,32 @@ export class EndpointUtil {
     } else if (param.location === 'query') {
       // TODO: Revisit this logic?
       const withQuery: typeof request & { [WebQueryExpandedSymbol]?: Record<string, unknown> } = request;
-      const q = withQuery[WebQueryExpandedSymbol] ??= BindUtil.expandPaths(request.context.httpQuery ?? {});
+      const query = withQuery[WebQueryExpandedSymbol] ??= BindUtil.expandPaths(request.context.httpQuery ?? {});
       if (param.prefix) { // Has a prefix provided
-        return q[param.prefix];
+        return query[param.prefix];
       } else if (input.type.Ⲑid) { // Is a full type
-        return q;
+        return query;
       }
     }
 
-    let res = this.extractParameterValue(request, param, input.name!.toString(), input.array);
-    if (!res && input.aliases) {
-      for (const name of input.aliases) {
-        res = this.extractParameterValue(request, param, name, input.array);
-        if (res !== undefined) {
-          break;
-        }
-      }
+    let result = this.extractParameterValue(request, param, input.name!, input.array) ?? undefined;
+    for (let i = 0; result === undefined && input.aliases && i < input.aliases.length; i += 1) {
+      result = this.extractParameterValue(request, param, input.aliases[i], input.array) ?? undefined;
     }
-    return res;
+    return result;
   }
 
   /**
    * Extract all parameters for a given endpoint/request/response combo
    * @param endpoint The endpoint to extract for
-   * @param req The request
-   * @param res The response
+   * @param request The request
    */
   static async extractParameters(endpoint: EndpointConfig, request: WebRequest): Promise<unknown[]> {
     const cls = endpoint.class;
     const vals = WebCommonUtil.getRequestParams(request);
-    const { parameters } = SchemaRegistryIndex.getMethodConfig(cls, endpoint.methodName);
-    const combined = parameters.map((cfg) =>
-      ({ schema: cfg, param: endpoint.parameters[cfg.index], value: vals?.[cfg.index] }));
+    const { parameters } = SchemaRegistryIndex.get(cls).getMethod(endpoint.methodName);
+    const combined = parameters.map((config) =>
+      ({ schema: config, param: endpoint.parameters[config.index], value: vals?.[config.index] }));
 
     try {
       const extracted = combined.map(({ param, schema, value }) =>
@@ -154,20 +148,20 @@ export class EndpointUtil {
           this.extractParameter(request, param, schema)
       );
       const params = BindUtil.coerceMethodParams(cls, endpoint.methodName, extracted);
-      await SchemaValidator.validateMethod(cls, endpoint.methodName, params, endpoint.parameters.map(x => x.prefix));
+      await SchemaValidator.validateMethod(cls, endpoint.methodName, params, endpoint.parameters.map(paramConfig => paramConfig.prefix));
       return params;
-    } catch (err) {
-      if (err instanceof ValidationResultError) {
-        for (const el of err.details?.errors ?? []) {
-          if (el.kind === 'required') {
-            const config = combined.find(x => x.schema.name === el.path);
+    } catch (error) {
+      if (error instanceof ValidationResultError) {
+        for (const validationError of error.details?.errors ?? []) {
+          if (validationError.kind === 'required') {
+            const config = combined.find(paramConfig => paramConfig.schema.name === validationError.path);
             if (config) {
-              el.message = `Missing ${config.param.location} value: ${config.schema.name}`;
+              validationError.message = `Missing ${config.param.location} value: ${config.schema.name}`;
             }
           }
         }
       }
-      throw err;
+      throw error;
     }
   }
 
@@ -181,7 +175,7 @@ export class EndpointUtil {
       const headers = endpoint.finalizedResponseHeaders;
       let response: WebResponse;
       if (body instanceof WebResponse) {
-        for (const [k, v] of headers) { body.headers.setIfAbsent(k, v); }
+        for (const [key, value] of headers) { body.headers.setIfAbsent(key, value); }
         // Rewrite context
         Object.assign(body.context, { ...endpoint.responseContext, ...body.context });
         response = body;
@@ -189,8 +183,8 @@ export class EndpointUtil {
         response = new WebResponse({ body, headers, context: { ...endpoint.responseContext } });
       }
       return endpoint.responseFinalizer?.(response) ?? response;
-    } catch (err) {
-      throw WebCommonUtil.catchResponse(err);
+    } catch (error) {
+      throw WebCommonUtil.catchResponse(error);
     }
   }
 
@@ -208,7 +202,7 @@ export class EndpointUtil {
 
     // Filter interceptors if needed
     for (const filter of [controller?.interceptorExclude, endpoint.interceptorExclude]) {
-      interceptors = filter ? interceptors.filter(x => !filter(x)) : interceptors;
+      interceptors = filter ? interceptors.filter(interceptor => !filter(interceptor)) : interceptors;
     }
 
     const interceptorFilters =
@@ -219,7 +213,7 @@ export class EndpointUtil {
     const endpointFilters = [
       ...(controller?.filters ?? []).map(fn => fn.bind(controller?.instance)),
       ...(endpoint.filters ?? []).map(fn => fn.bind(endpoint.instance)),
-      ...(endpoint.parameters.filter(cfg => cfg.resolve).map(fn => fn.resolve!))
+      ...(endpoint.parameters.filter(config => config.resolve).map(fn => fn.resolve!))
     ]
       .map(fn => ({ filter: fn }));
 
@@ -236,8 +230,8 @@ export class EndpointUtil {
   /**
    * Get bound endpoints, honoring the conditional status
    */
-  static async getBoundEndpoints(c: Class): Promise<EndpointConfig[]> {
-    const config = ControllerRegistryIndex.getConfig(c);
+  static async getBoundEndpoints(cls: Class): Promise<EndpointConfig[]> {
+    const config = ControllerRegistryIndex.getConfig(cls);
 
     // Skip registering conditional controllers
     if (config.conditional && !await config.conditional()) {
@@ -252,15 +246,15 @@ export class EndpointUtil {
 
     // Filter out conditional endpoints
     const endpoints = (await Promise.all(
-      config.endpoints.map(ep => Promise.resolve(ep.conditional?.() ?? true).then(v => v ? ep : undefined))
-    )).filter(x => !!x);
+      config.endpoints.map(endpoint => Promise.resolve(endpoint.conditional?.() ?? true).then(value => value ? endpoint : undefined))
+    )).filter(endpoint => !!endpoint);
 
     if (!endpoints.length) {
       return [];
     }
 
-    for (const ep of endpoints) {
-      ep.instance = config.instance;
+    for (const endpoint of endpoints) {
+      endpoint.instance = config.instance;
     }
 
     return endpoints;
@@ -271,12 +265,12 @@ export class EndpointUtil {
    */
   static orderEndpoints(endpoints: EndpointConfig[]): EndpointConfig[] {
     return endpoints
-      .map(ep => {
-        const parts = ep.path.replace(/^[/]|[/]$/g, '').split('/');
-        return [ep, parts.map(x => /[*]/.test(x) ? 1 : /:/.test(x) ? 2 : 3)] as const;
+      .map(endpoint => {
+        const parts = endpoint.path.replace(/^[/]|[/]$/g, '').split('/');
+        return [endpoint, parts.map(part => /[*]/.test(part) ? 1 : /:/.test(part) ? 2 : 3)] as const;
       })
       .toSorted((a, b) => this.#compareEndpoints(a[1], b[1]) || a[0].path.localeCompare(b[0].path))
-      .map(([ep,]) => ep);
+      .map(([endpoint,]) => endpoint);
   }
 
 
@@ -284,25 +278,25 @@ export class EndpointUtil {
    * Order interceptors
    */
   static orderInterceptors(instances: WebInterceptor[]): WebInterceptor[] {
-    const cats = WEB_INTERCEPTOR_CATEGORIES.map(x => ({
-      key: x,
-      start: castTo<Class<WebInterceptor>>({ name: `${x}Start` }),
-      end: castTo<Class<WebInterceptor>>({ name: `${x}End` }),
+    const categoryList = WEB_INTERCEPTOR_CATEGORIES.map(category => ({
+      key: category,
+      start: castTo<Class<WebInterceptor>>({ name: `${category}Start` }),
+      end: castTo<Class<WebInterceptor>>({ name: `${category}End` }),
     }));
 
-    const categoryMapping = TypedObject.fromEntries(cats.map(x => [x.key, x]));
+    const categoryMapping = TypedObject.fromEntries(categoryList.map(category => [category.key, category]));
 
-    const ordered = instances.map(x => {
-      const group = categoryMapping[x.category];
-      const after = [...x.dependsOn ?? [], group.start];
-      const before = [...x.runsBefore ?? [], group.end];
-      return ({ key: x.constructor, before, after, target: x, placeholder: false });
+    const ordered = instances.map(category => {
+      const group = categoryMapping[category.category];
+      const after = [...category.dependsOn ?? [], group.start];
+      const before = [...category.runsBefore ?? [], group.end];
+      return ({ key: category.constructor, before, after, target: category, placeholder: false });
     });
 
     // Add category sets into the ordering
     let i = 0;
-    for (const cat of cats) {
-      const prevEnd = cats[i - 1]?.end ? [cats[i - 1].end] : [];
+    for (const cat of categoryList) {
+      const prevEnd = categoryList[i - 1]?.end ? [categoryList[i - 1].end] : [];
       ordered.push(
         { key: cat.start, before: [cat.end], after: prevEnd, placeholder: true, target: undefined! },
         { key: cat.end, before: [], after: [cat.start], placeholder: true, target: undefined! }
@@ -311,7 +305,7 @@ export class EndpointUtil {
     }
 
     return WebCommonUtil.ordered(ordered)
-      .filter(x => !x.placeholder)  // Drop out the placeholders
-      .map(x => x.target);
+      .filter(category => !category.placeholder)  // Drop out the placeholders
+      .map(category => category.target);
   }
 }