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

package/src/router/base.ts

@@ -1,7 +1,6 @@
 import { Class, toConcrete } from '@travetto/runtime';
 import { DependencyRegistryIndex, Injectable } from '@travetto/di';
 import { ControllerRegistryIndex } from '@travetto/web';
-import { Registry } from '@travetto/registry';
 
 import { ControllerConfig, EndpointConfig } from '../registry/types.ts';
 import type { WebRouter } from '../types/dispatch.ts';
@@ -17,21 +16,19 @@ import { EndpointUtil } from '../util/endpoint.ts';
 @Injectable()
 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);
+    await this.register(endpoints, config);
   };
 
   /**
@@ -41,29 +38,15 @@ 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 });
-
-      if ('prev' in e) {
-        this.#cleanup.get(e.prev.Ⲑid)?.();
-        this.#cleanup.delete(e.prev.Ⲑid);
-      }
-      if ('curr' in e) {
-        await this.#register(e.curr);
-      }
-    }, ControllerRegistryIndex);
   }
 
-  abstract register(endpoints: EndpointConfig[], controller: ControllerConfig): Promise<() => void>;
+  abstract register(endpoints: EndpointConfig[], controller: ControllerConfig): Promise<void>;
   abstract dispatch(ctx: WebFilterContext): Promise<WebResponse>;
 }

package/src/router/standard.ts

@@ -26,19 +26,13 @@ export class StandardWebRouter extends BaseWebRouter {
   #cache = new Map<Function, EndpointConfig>();
   raw = router();
 
-  async register(endpoints: EndpointConfig[]): Promise<() => void> {
-    for (const ep of endpoints) {
-      const fullPath = ep.fullPath.replace(/[*][^*]+/g, '*'); // Flatten wildcards
+  async register(endpoints: EndpointConfig[]): Promise<void> {
+    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);
-      }
-    };
   }
 
   /**

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/dispatch.ts

@@ -19,5 +19,5 @@ export interface WebRouter extends WebDispatcher {
   /**
    * Register a controller with the prepared endpoints
    */
-  register(endpoints: EndpointConfig[], controller: ControllerConfig): Promise<() => void>;
+  register(endpoints: EndpointConfig[], controller: ControllerConfig): Promise<void>;
 }

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/types/response.ts

@@ -12,10 +12,10 @@ export interface WebResponseContext {
 export class WebResponse<B = unknown> extends BaseWebMessage<B, WebResponseContext> {
 
   /**
-    * Build the redirect
-    * @param location Location to redirect to
-    * @param statusCode Status code
-    */
+   * Build the redirect
+   * @param location Location to redirect to
+   * @param statusCode Status code
+   */
   static redirect(location: string, statusCode = 302): WebResponse<undefined> {
     return new WebResponse({ context: { httpStatusCode: statusCode }, headers: { Location: location } });
   }

package/src/util/body.ts

@@ -1,7 +1,7 @@
 import { TextDecoder } from 'node:util';
 import { Readable } from 'node:stream';
 
-import { Any, BinaryUtil, castTo, hasToJSON, Util } from '@travetto/runtime';
+import { Any, BinaryUtil, castTo, hasToJSON, JSONUtil, Util } from '@travetto/runtime';
 
 import { WebBinaryBody, WebMessage } from '../types/message.ts';
 import { WebHeaders } from '../types/headers.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 JSONUtil.parseSafe(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));
   }
 }