@travetto/web 7.0.0-rc.2 → 7.0.0-rc.4

package/src/util/endpoint.ts

@@ -1,7 +1,6 @@
-import { asConstructable, castKey, castTo, Class, Runtime, TypedObject } from '@travetto/runtime';
+import { asConstructable, castKey, castTo, Class, TypedObject } from '@travetto/runtime';
 import { BindUtil, SchemaParameterConfig, SchemaRegistryIndex, SchemaValidator, ValidationResultError } from '@travetto/schema';
 import { DependencyRegistryIndex } from '@travetto/di';
-import { RetargettingProxy } from '@travetto/registry';
 
 import { WebChainedFilter, WebChainedContext, WebFilter } from '../types/filter.ts';
 import { WebResponse } from '../types/response.ts';
@@ -65,12 +64,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 +95,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,33 +113,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) ?? undefined;
-    for (let i = 0; res === undefined && input.aliases && i < input.aliases.length; i += 1) {
-      res = this.extractParameterValue(request, param, input.aliases[i], input.array) ?? undefined;
+    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.get(cls).getMethod(endpoint.methodName);
-    const combined = parameters.map((cfg) =>
-      ({ schema: cfg, param: endpoint.parameters[cfg.index], value: vals?.[cfg.index] }));
+    const combined = parameters.map((config) =>
+      ({ schema: config, param: endpoint.parameters[config.index], value: vals?.[config.index] }));
 
     try {
       const extracted = combined.map(({ param, schema, value }) =>
@@ -149,20 +147,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;
     }
   }
 
@@ -176,7 +174,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;
@@ -184,8 +182,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);
     }
   }
 
@@ -203,7 +201,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 =
@@ -214,7 +212,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 }));
 
@@ -231,8 +229,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()) {
@@ -241,21 +239,17 @@ export class EndpointUtil {
 
     config.instance = await DependencyRegistryIndex.getInstance(config.class);
 
-    if (Runtime.dynamic) {
-      config.instance = RetargettingProxy.unwrap(config.instance);
-    }
-
     // 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;
@@ -266,12 +260,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);
   }
 
 
@@ -279,25 +273,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! }
@@ -306,7 +300,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);
   }
 }

package/src/util/header.ts

@@ -19,8 +19,8 @@ export class WebHeaderUtil {
    * Parse cookie header
    */
   static parseCookieHeader(header: string): Cookie[] {
-    const val = header.trim();
-    return !val ? [] : val.split(SPLIT_SEMI).map(item => {
+    const text = header.trim();
+    return !text ? [] : text.split(SPLIT_SEMI).map(item => {
       const [name, value] = item.split(SPLIT_EQ);
       return { name, value };
     });
@@ -32,17 +32,17 @@ export class WebHeaderUtil {
   static parseSetCookieHeader(header: string): Cookie {
     const parts = header.split(SPLIT_SEMI);
     const [name, value] = parts[0].split(SPLIT_EQ);
-    const c: Cookie = { name, value };
-    for (const p of parts.slice(1)) {
-      const [k, pv = ''] = p.toLowerCase().split(SPLIT_EQ);
-      const v = pv.charCodeAt(0) === QUOTE ? pv.slice(1, -1) : pv;
-      if (k === 'expires') {
-        c[k] = new Date(v);
+    const result: Cookie = { name, value };
+    for (const part of parts.slice(1)) {
+      const [key, partValue = ''] = part.toLowerCase().split(SPLIT_EQ);
+      const cleanedValue = partValue.charCodeAt(0) === QUOTE ? partValue.slice(1, -1) : partValue;
+      if (key === 'expires') {
+        result[key] = new Date(cleanedValue);
       } else {
-        c[castKey(k)] = castTo(v || true);
+        result[castKey(key)] = castTo(cleanedValue || true);
       }
     }
-    return c;
+    return result;
   }
 
   /**
@@ -53,20 +53,20 @@ export class WebHeaderUtil {
     if (!input) {
       return { value: '', parameters: {} };
     }
-    const [rv, ...parts] = input.split(SPLIT_SEMI);
+    const [rawValue, ...parts] = input.split(SPLIT_SEMI);
     const item: WebParsedHeader = { value: '', parameters: {} };
-    const value = rv.charCodeAt(0) === QUOTE ? rv.slice(1, -1) : rv;
+    const value = rawValue.charCodeAt(0) === QUOTE ? rawValue.slice(1, -1) : rawValue;
     if (value.includes('=')) {
       parts.unshift(value);
     } else {
       item.value = value;
     }
     for (const part of parts) {
-      const [k, pv = ''] = part.split(SPLIT_EQ);
-      const v = (pv.charCodeAt(0) === QUOTE) ? pv.slice(1, -1) : pv;
-      item.parameters[k] = v;
-      if (k === 'q') {
-        item.q = parseFloat(v);
+      const [key, partValue = ''] = part.split(SPLIT_EQ);
+      const cleanedValue = (partValue.charCodeAt(0) === QUOTE) ? partValue.slice(1, -1) : partValue;
+      item.parameters[key] = cleanedValue;
+      if (key === 'q') {
+        item.q = parseFloat(cleanedValue);
       }
     }
     return item;
@@ -76,24 +76,24 @@ export class WebHeaderUtil {
    * Parse full header
    */
   static parseHeader(input: string): WebParsedHeader[] {
-    const v = input.trim();
+    const value = input.trim();
     if (!input) { return []; }
-    return v.split(SPLIT_COMMA).map(x => this.parseHeaderSegment(x));
+    return value.split(SPLIT_COMMA).map(part => this.parseHeaderSegment(part));
   }
 
   /**
    * Build cookie suffix
    */
-  static buildCookieSuffix(c: Cookie): string[] {
+  static buildCookieSuffix(cookie: Cookie): string[] {
     const parts = [];
-    if (c.path) { parts.push(`path=${c.path}`); }
-    if (c.expires) { parts.push(`expires=${c.expires.toUTCString()}`); }
-    if (c.domain) { parts.push(`domain=${c.domain}`); }
-    if (c.priority) { parts.push(`priority=${c.priority.toLowerCase()}`); }
-    if (c.sameSite) { parts.push(`samesite=${c.sameSite.toLowerCase()}`); }
-    if (c.secure) { parts.push('secure'); }
-    if (c.httponly) { parts.push('httponly'); }
-    if (c.partitioned) { parts.push('partitioned'); }
+    if (cookie.path) { parts.push(`path=${cookie.path}`); }
+    if (cookie.expires) { parts.push(`expires=${cookie.expires.toUTCString()}`); }
+    if (cookie.domain) { parts.push(`domain=${cookie.domain}`); }
+    if (cookie.priority) { parts.push(`priority=${cookie.priority.toLowerCase()}`); }
+    if (cookie.sameSite) { parts.push(`samesite=${cookie.sameSite.toLowerCase()}`); }
+    if (cookie.secure) { parts.push('secure'); }
+    if (cookie.httponly) { parts.push('httponly'); }
+    if (cookie.partitioned) { parts.push('partitioned'); }
     return parts;
   }
 
@@ -104,7 +104,10 @@ export class WebHeaderUtil {
     if (header === '*' || header === '*/*') {
       return values[0];
     }
-    const sorted = this.parseHeader(header.toLowerCase()).filter(x => (x.q ?? 1) > 0).toSorted((a, b) => (b.q ?? 1) - (a.q ?? 1));
+    const sorted = this.parseHeader(header.toLowerCase())
+      .filter(item => (item.q ?? 1) > 0)
+      .toSorted((a, b) => (b.q ?? 1) - (a.q ?? 1));
+
     const set = new Set(values);
     for (const { value } of sorted) {
       const vk: K = castKey(value);
@@ -127,7 +130,7 @@ export class WebHeaderUtil {
     const { parameters } = this.parseHeaderSegment(headers.get('Range'));
     if ('bytes' in parameters) {
       const [start, end] = parameters.bytes.split('-')
-        .map(x => x ? parseInt(x, 10) : undefined);
+        .map(value => value ? parseInt(value, 10) : undefined);
       if (start !== undefined) {
         return { start, end: end ?? (start + chunkSize) };
       }
@@ -137,20 +140,20 @@ export class WebHeaderUtil {
   /**
    * Check freshness of the response using request and response headers.
    */
-  static isFresh(req: WebHeaders, res: WebHeaders): boolean {
-    const cacheControl = req.get('Cache-Control');
+  static isFresh(request: WebHeaders, response: WebHeaders): boolean {
+    const cacheControl = request.get('Cache-Control');
     if (cacheControl?.includes('no-cache')) {
       return false;
     }
 
-    const noneMatch = req.get('If-None-Match');
+    const noneMatch = request.get('If-None-Match');
     if (noneMatch) {
-      const etag = res.get('ETag');
-      const validTag = (v: string): boolean => v === etag || v === `W/${etag}` || `W/${v}` === etag;
+      const etag = response.get('ETag');
+      const validTag = (value: string): boolean => value === etag || value === `W/${etag}` || `W/${value}` === etag;
       return noneMatch === '*' || (!!etag && noneMatch.split(SPLIT_COMMA).some(validTag));
     } else {
-      const modifiedSince = req.get('If-Modified-Since');
-      const lastModified = res.get('Last-Modified');
+      const modifiedSince = request.get('If-Modified-Since');
+      const lastModified = response.get('Last-Modified');
       if (!modifiedSince || !lastModified) {
         return false;
       }

package/src/util/keygrip.ts

@@ -30,7 +30,7 @@ export class KeyGrip {
       .createHmac(this.#algorithm, key ?? this.#keys[0])
       .update(data)
       .digest(this.#encoding)
-      .replace(/[/+=]/g, x => CHAR_MAPPING[castKey(x)]);
+      .replace(/[/+=]/g, ch => CHAR_MAPPING[castKey(ch)]);
   }
 
   verify(data: string, digest: string): boolean {

package/src/util/net.ts

@@ -8,25 +8,25 @@ import { ExecUtil } from '@travetto/runtime';
 export class NetUtil {
 
   /** Is an error an address in use error */
-  static isPortUsedError(err: unknown): err is Error & { port: number } {
-    return !!err && err instanceof Error && err.message.includes('EADDRINUSE');
+  static isPortUsedError(error: unknown): error is Error & { port: number } {
+    return !!error && error instanceof Error && error.message.includes('EADDRINUSE');
   }
 
   /** Get the port process id */
   static async getPortProcessId(port: number): Promise<number | undefined> {
-    const proc = spawn('lsof', ['-t', '-i', `tcp:${port}`]);
-    const result = await ExecUtil.getResult(proc, { catch: true });
-    const [pid] = result.stdout.trim().split(/\n/g);
-    if (pid && +pid > 0) {
-      return +pid;
+    const subProcess = spawn('lsof', ['-t', '-i', `tcp:${port}`]);
+    const result = await ExecUtil.getResult(subProcess, { catch: true });
+    const [processId] = result.stdout.trim().split(/\n/g);
+    if (processId && +processId > 0) {
+      return +processId;
     }
   }
 
   /** Free port if in use */
   static async freePort(port: number): Promise<void> {
-    const pid = await this.getPortProcessId(port);
-    if (pid) {
-      process.kill(pid);
+    const processId = await this.getPortProcessId(port);
+    if (processId) {
+      process.kill(processId);
     }
   }
 
@@ -54,19 +54,19 @@ export class NetUtil {
    */
   static getLocalAddress(): string {
     const useIPv4 = !![...Object.values(os.networkInterfaces())]
-      .find(interfaces => interfaces?.find(nic => nic.family === 'IPv4'));
+      .find(interfaces => interfaces?.find(item => item.family === 'IPv4'));
 
     return useIPv4 ? '0.0.0.0' : '::';
   }
 
   /**
    * Free a port if it is in use, typically used to resolve port conflicts.
-   * @param err The error that may indicate a port conflict
+   * @param error The error that may indicate a port conflict
    * @returns Returns true if the port was freed, false if not handled
    */
-  static async freePortOnConflict(err: unknown): Promise<boolean> {
-    if (NetUtil.isPortUsedError(err) && typeof err.port === 'number') {
-      await NetUtil.freePort(err.port);
+  static async freePortOnConflict(error: unknown): Promise<boolean> {
+    if (NetUtil.isPortUsedError(error) && typeof error.port === 'number') {
+      await NetUtil.freePort(error.port);
       return true;
     } else {
       return false;

package/support/test/dispatch-util.ts

@@ -1,7 +1,7 @@
 import { buffer } from 'node:stream/consumers';
 import { Readable } from 'node:stream';
 
-import { AppError, BinaryUtil, castTo } from '@travetto/runtime';
+import { AppError, BinaryUtil, castTo, JSONUtil } from '@travetto/runtime';
 import { BindUtil } from '@travetto/schema';
 
 import { WebResponse } from '../../src/types/response.ts';
@@ -51,7 +51,7 @@ export class WebTestDispatchUtil {
 
     if (text) {
       switch (response.headers.get('Content-Type')) {
-        case 'application/json': result = JSON.parse(castTo(text)); break;
+        case 'application/json': result = JSONUtil.parseSafe(castTo(text)); break;
         case 'text/plain': result = text; break;
       }
     }

package/support/test/suite/base.ts

@@ -2,7 +2,7 @@ import { Registry } from '@travetto/registry';
 import { castTo, Class } from '@travetto/runtime';
 import { AfterAll, BeforeAll } from '@travetto/test';
 import { DependencyRegistryIndex, Injectable } from '@travetto/di';
-import { ConfigSource, ConfigSpec } from '@travetto/config';
+import { ConfigSource, ConfigPayload } from '@travetto/config';
 import { Schema } from '@travetto/schema';
 
 import { WebDispatcher } from '../../../src/types/dispatch.ts';
@@ -12,7 +12,7 @@ import { WebMessageInit } from '../../../src/types/message.ts';
 
 @Injectable()
 export class WebTestConfig implements ConfigSource {
-  async get(): Promise<ConfigSpec> {
+  async get(): Promise<ConfigPayload> {
     return {
       data: {
         web: {

package/support/test/suite/standard.ts

@@ -1,19 +1,13 @@
 import assert from 'node:assert';
 
-import { Test, Suite, BeforeAll } from '@travetto/test';
-import { Registry } from '@travetto/registry';
+import { Test, Suite } from '@travetto/test';
 
 import { BaseWebSuite } from './base.ts';
-import { TestController } from './controller.ts';
+import './controller.ts'; // Ensure imported
 
 @Suite()
 export abstract class StandardWebServerSuite extends BaseWebSuite {
 
-  @BeforeAll()
-  async init() {
-    Registry.process([{ type: 'added', curr: TestController }]);
-  }
-
   @Test()
   async getJSON() {
     const response = await this.request({ context: { httpMethod: 'GET', path: '/test/json' } });