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

package/README.md

@@ -30,7 +30,7 @@ export class BaseWebMessage<B = unknown, C = unknown> implements WebMessage<B, C
   readonly context: C;
   readonly headers: WebHeaders;
   body?: B;
-  constructor(o: WebMessageInit<B, C> = {});
+  constructor(input: WebMessageInit<B, C> = {});
 }
 ```
 
@@ -667,7 +667,7 @@ export class AlowDenyController {
   }
 
   @Get('/raw')
-  @ExcludeInterceptors(v => v.category === 'response')
+  @ExcludeInterceptors(({ category }) => category === 'response')
   withoutResponse(@QueryParam() value: string) {
 
   }
@@ -742,8 +742,8 @@ Cookies are a unique element, within the framework, as they sit on the request a
 export class CookieJar {
   constructor({ keys, ...options }: CookieJarOptions = {});
   import(cookies: Cookie[]): this;
-  has(name: string, opts: CookieGetOptions = {}): boolean;
-  get(name: string, opts: CookieGetOptions = {}): string | undefined;
+  has(name: string, options: CookieGetOptions = {}): boolean;
+  get(name: string, options: CookieGetOptions = {}): string | undefined;
   set(cookie: Cookie): void;
   getAll(): Cookie[];
   importCookieHeader(header: string | null | undefined): this;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/web",
-  "version": "7.0.0-rc.2",
+  "version": "7.0.0-rc.3",
   "description": "Declarative support for creating Web Applications",
   "keywords": [
     "web",
@@ -25,18 +25,18 @@
     "directory": "module/web"
   },
   "dependencies": {
-    "@travetto/config": "^7.0.0-rc.1",
-    "@travetto/context": "^7.0.0-rc.1",
-    "@travetto/di": "^7.0.0-rc.1",
-    "@travetto/registry": "^7.0.0-rc.1",
-    "@travetto/runtime": "^7.0.0-rc.1",
-    "@travetto/schema": "^7.0.0-rc.1",
+    "@travetto/config": "^7.0.0-rc.2",
+    "@travetto/context": "^7.0.0-rc.2",
+    "@travetto/di": "^7.0.0-rc.2",
+    "@travetto/registry": "^7.0.0-rc.2",
+    "@travetto/runtime": "^7.0.0-rc.2",
+    "@travetto/schema": "^7.0.0-rc.2",
     "find-my-way": "^9.3.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.0.0-rc.1",
-    "@travetto/test": "^7.0.0-rc.1",
-    "@travetto/transformer": "^7.0.0-rc.1"
+    "@travetto/cli": "^7.0.0-rc.2",
+    "@travetto/test": "^7.0.0-rc.2",
+    "@travetto/transformer": "^7.0.0-rc.2"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/decorator/common.ts

@@ -10,7 +10,7 @@ function isClass(target: unknown, property: unknown,): target is Class<unknown>
 }
 
 function register(config: Partial<EndpointConfig | ControllerConfig>): EndpointDecorator {
-  return function <T>(instanceOrCls: ClassInstance | Class<T>, property?: string | symbol, _?: EndpointFunctionDescriptor) {
+  return function <T>(instanceOrCls: ClassInstance | Class<T>, property?: string, _?: EndpointFunctionDescriptor) {
     const adapter = ControllerRegistryIndex.getForRegister(getClass(instanceOrCls));
     if (isClass(instanceOrCls, property)) {
       adapter.register(config);
@@ -74,10 +74,10 @@ export function Accepts(types: [string, ...string[]]): EndpointDecorator {
  */
 export const ConfigureInterceptor = <T extends WebInterceptor>(
   cls: Class<T>,
-  cfg: Partial<RetainPrimitiveFields<T['config']>>,
+  config: Partial<RetainPrimitiveFields<T['config']>>,
   extra?: Partial<EndpointConfig & ControllerConfig>
 ): EndpointDecorator =>
-  ControllerRegistryIndex.createInterceptorConfigDecorator(cls, cfg, extra);
+  ControllerRegistryIndex.createInterceptorConfigDecorator(cls, config, extra);
 
 /**
  * Specifies if endpoint should be conditional
@@ -91,6 +91,6 @@ export function ConditionalRegister(handler: () => (boolean | Promise<boolean>))
  * Registers an interceptor exclusion filter
  * @kind decorator
  */
-export function ExcludeInterceptors(interceptorExclude: (val: WebInterceptor) => boolean): EndpointDecorator {
+export function ExcludeInterceptors(interceptorExclude: (value: WebInterceptor) => boolean): EndpointDecorator {
   return register({ interceptorExclude });
 };

package/src/decorator/endpoint.ts

@@ -4,7 +4,7 @@ import { EndpointConfig, EndpointFunctionDescriptor } from '../registry/types.ts
 import { HTTP_METHODS, HttpMethod } from '../types/core.ts';
 import { ControllerRegistryIndex } from '../registry/registry-index.ts';
 
-type EndpointFunctionDecorator = <T>(instance: T, property: symbol | string, descriptor: EndpointFunctionDescriptor) => EndpointFunctionDescriptor;
+type EndpointFunctionDecorator = <T>(instance: T, property: string, descriptor: EndpointFunctionDescriptor) => EndpointFunctionDescriptor;
 
 type EndpointDecConfig = Partial<EndpointConfig> & { path: string };
 
@@ -12,7 +12,7 @@ type EndpointDecConfig = Partial<EndpointConfig> & { path: string };
  * Generic Endpoint Decorator
  */
 export function Endpoint(config: EndpointDecConfig): EndpointFunctionDecorator {
-  return function (instance: ClassInstance, property: symbol | string, descriptor: EndpointFunctionDescriptor): EndpointFunctionDescriptor {
+  return function (instance: ClassInstance, property: string, descriptor: EndpointFunctionDescriptor): EndpointFunctionDescriptor {
     ControllerRegistryIndex.getForRegister(getClass(instance)).registerEndpoint(property, { methodName: property }, config);
     return descriptor;
   };
@@ -25,9 +25,9 @@ function HttpEndpoint(method: HttpMethod, path: string): EndpointFunctionDecorat
     allowsBody,
     cacheable,
     httpMethod: method,
-    responseFinalizer: v => {
-      v.context.httpStatusCode ??= (v.body === null || v.body === undefined || v.body === '') ? emptyStatusCode : 200;
-      return v;
+    responseFinalizer: value => {
+      value.context.httpStatusCode ??= (value.body === null || value.body === undefined || value.body === '') ? emptyStatusCode : 200;
+      return value;
     }
   });
 }

package/src/decorator/param.ts

@@ -4,7 +4,7 @@ import { SchemaRegistryIndex } from '@travetto/schema';
 import { ControllerRegistryIndex } from '../registry/registry-index.ts';
 import { EndpointParameterConfig, EndpointParamLocation } from '../registry/types.ts';
 
-type ParamDecorator = (instance: ClassInstance, property: string | symbol, idx: number) => void;
+type ParamDecorator = (instance: ClassInstance, property: string, idx: number) => void;
 
 /**
  * Define a parameter
@@ -14,7 +14,7 @@ type ParamDecorator = (instance: ClassInstance, property: string | symbol, idx:
  * @kind decorator
  */
 export function Param(location: EndpointParamLocation, aliasOrConfig: string | Partial<EndpointParameterConfig>): ParamDecorator {
-  return (instance: ClassInstance, property: string | symbol, idx: number): void => {
+  return (instance: ClassInstance, property: string, idx: number): void => {
     const config = typeof aliasOrConfig === 'string' ? {} : aliasOrConfig;
     const cls = getClass(instance);
     if (typeof aliasOrConfig === 'string') {
@@ -62,7 +62,7 @@ export function Body(input: Partial<EndpointParameterConfig> = {}): ParamDecorat
  * @kind decorator
  */
 export function ContextParam() {
-  return (instance: ClassInstance, property: string | symbol): void => {
+  return (instance: ClassInstance, property: string): void => {
     ControllerRegistryIndex.getForRegister(getClass(instance)).register({ contextParams: { [property]: true } });
     ControllerRegistryIndex.bindContextParamsOnPostConstruct(getClass(instance));
   };

package/src/interceptor/accept.ts

@@ -56,14 +56,14 @@ export class AcceptInterceptor implements WebInterceptor<AcceptConfig> {
   }
 
   async filter({ request, config, next }: WebChainedContext<AcceptConfig>): Promise<WebResponse> {
-    let res: WebResponse | undefined;
+    let response: WebResponse | undefined;
     try {
       this.validate(request, config);
-      return res = await next();
-    } catch (err) {
-      throw res = await WebCommonUtil.catchResponse(err);
+      return response = await next();
+    } catch (error) {
+      throw response = await WebCommonUtil.catchResponse(error);
     } finally {
-      res?.headers.setIfAbsent('Accept', config.types.join(','));
+      response?.headers.setIfAbsent('Accept', config.types.join(','));
     }
   }
 }

package/src/interceptor/body.ts

@@ -114,8 +114,8 @@ export class BodyInterceptor implements WebInterceptor<WebBodyConfig> {
         WebBodyUtil.parseBody(parserType, text);
 
       return next();
-    } catch (err) {
-      throw WebError.for('Malformed input', 400, { cause: err });
+    } catch (error) {
+      throw WebError.for('Malformed input', 400, { cause: error });
     }
   }
 }

package/src/interceptor/compress.ts

@@ -81,8 +81,8 @@ export class CompressInterceptor implements WebInterceptor {
       return binaryResponse;
     }
 
-    const opts = type === 'br' ? { params: { [constants.BROTLI_PARAM_QUALITY]: 4, ...raw.params }, ...raw } : { ...raw };
-    const stream = COMPRESSORS[type](opts);
+    const options = type === 'br' ? { params: { [constants.BROTLI_PARAM_QUALITY]: 4, ...raw.params }, ...raw } : { ...raw };
+    const stream = COMPRESSORS[type](options);
 
     // If we are compressing
     binaryResponse.headers.set('Content-Encoding', type);

package/src/interceptor/cookie.ts

@@ -96,7 +96,7 @@ export class CookieInterceptor implements WebInterceptor<CookieConfig> {
     this.#cookieJar.set(jar);
 
     const response = await next();
-    for (const c of jar.exportSetCookieHeader()) { response.headers.append('Set-Cookie', c); }
+    for (const cookie of jar.exportSetCookieHeader()) { response.headers.append('Set-Cookie', cookie); }
     return response;
   }
 }

package/src/interceptor/cors.ts

@@ -72,13 +72,13 @@ export class CorsInterceptor implements WebInterceptor<CorsConfig> {
   decorate(request: WebRequest, resolved: CorsConfig['resolved'], response: WebResponse,): WebResponse {
     const origin = request.headers.get('Origin');
     if (resolved.origins.size === 0 || resolved.origins.has(origin!)) {
-      for (const [k, v] of [
+      for (const [header, value] of [
         ['Access-Control-Allow-Origin', origin || '*'],
         ['Access-Control-Allow-Credentials', `${resolved.credentials}`],
         ['Access-Control-Allow-Methods', resolved.methods],
         ['Access-Control-Allow-Headers', resolved.headers || request.headers.get('Access-Control-Request-Headers') || '*'],
       ]) {
-        response.headers.setIfAbsent(k, v);
+        response.headers.setIfAbsent(header, value);
       }
     }
     return response;
@@ -87,8 +87,8 @@ export class CorsInterceptor implements WebInterceptor<CorsConfig> {
   async filter({ request, config: { resolved }, next }: WebChainedContext<CorsConfig>): Promise<WebResponse> {
     try {
       return this.decorate(request, resolved, await next());
-    } catch (err) {
-      throw this.decorate(request, resolved, WebCommonUtil.catchResponse(err));
+    } catch (error) {
+      throw this.decorate(request, resolved, WebCommonUtil.catchResponse(error));
     }
   }
 }

package/src/interceptor/logging.ts

@@ -41,8 +41,8 @@ export class LoggingInterceptor implements WebInterceptor {
     const response = await next();
     const duration = Date.now() - createdDate;
 
-    const err = response.body instanceof Error ? response.body : undefined;
-    const code = response.context.httpStatusCode ??= (!!err ? 500 : 200);
+    const error = response.body instanceof Error ? response.body : undefined;
+    const code = response.context.httpStatusCode ??= (!!error ? 500 : 200);
 
     const logMessage = {
       method: request.context.httpMethod,
@@ -61,8 +61,8 @@ export class LoggingInterceptor implements WebInterceptor {
       console.error('Request', logMessage);
     }
 
-    if (this.config.showStackTrace && err) {
-      console.error(err.message, { error: err });
+    if (this.config.showStackTrace && error) {
+      console.error(error.message, { error });
     }
 
     return response;

package/src/interceptor/respond.ts

@@ -15,12 +15,12 @@ export class RespondInterceptor implements WebInterceptor {
   dependsOn = [LoggingInterceptor];
 
   async filter(ctx: WebChainedContext): Promise<WebResponse> {
-    let res;
+    let response;
     try {
-      res = await ctx.next();
-    } catch (err) {
-      res = WebCommonUtil.catchResponse(err);
+      response = await ctx.next();
+    } catch (error) {
+      response = WebCommonUtil.catchResponse(error);
     }
-    return res;
+    return response;
   }
 }

package/src/registry/registry-adapter.ts

@@ -30,7 +30,7 @@ function combineClassConfigs(base: ControllerConfig, ...overrides: Partial<Contr
   return base;
 }
 
-function combineEndpointConfigs(ctrl: ControllerConfig, base: EndpointConfig, ...overrides: Partial<EndpointConfig>[]): EndpointConfig {
+function combineEndpointConfigs(controller: ControllerConfig, base: EndpointConfig, ...overrides: Partial<EndpointConfig>[]): EndpointConfig {
   for (const override of overrides) {
     combineCommon(base, override);
     Object.assign(
@@ -40,7 +40,7 @@ function combineEndpointConfigs(ctrl: ControllerConfig, base: EndpointConfig, ..
         httpMethod: override.httpMethod ?? base.httpMethod,
         allowsBody: override.allowsBody ?? base.allowsBody,
         path: override.path || base.path,
-        parameters: (override.parameters ?? base.parameters).map(x => ({ ...x })),
+        parameters: (override.parameters ?? base.parameters).map(endpoint => ({ ...endpoint })),
         responseFinalizer: override.responseFinalizer ?? base.responseFinalizer,
       }
     );
@@ -55,17 +55,17 @@ function combineEndpointConfigs(ctrl: ControllerConfig, base: EndpointConfig, ..
 /**
  * Compute the location of a parameter within an endpoint
  */
-function computeParameterLocation(ep: EndpointConfig, schema: SchemaParameterConfig): EndpointParamLocation {
-  const name = schema?.name;
-  if (!SchemaRegistryIndex.has(schema.type)) {
-    if ((schema.type === String || schema.type === Number) && name && ep.path.includes(`:${name.toString()}`)) {
+function computeParameterLocation(endpoint: EndpointConfig, param: SchemaParameterConfig): EndpointParamLocation {
+  const name = param?.name;
+  if (!SchemaRegistryIndex.has(param.type)) {
+    if ((param.type === String || param.type === Number) && name && endpoint.path.includes(`:${name}`)) {
       return 'path';
-    } else if (schema.type === Blob || schema.type === File || schema.type === ArrayBuffer || schema.type === Uint8Array) {
+    } else if (param.type === Blob || param.type === File || param.type === ArrayBuffer || param.type === Uint8Array) {
       return 'body';
     }
     return 'query';
   } else {
-    return ep.allowsBody ? 'body' : 'query';
+    return endpoint.allowsBody ? 'body' : 'query';
   }
 }
 
@@ -74,7 +74,7 @@ function computeParameterLocation(ep: EndpointConfig, schema: SchemaParameterCon
  */
 export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConfig> {
   #config: ControllerConfig;
-  #endpoints: Map<string | symbol, EndpointConfig> = new Map();
+  #endpoints: Map<string, EndpointConfig> = new Map();
   #cls: Class;
   #finalizeHandlers: Function[] = [];
 
@@ -97,7 +97,7 @@ export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConf
     return this.#config;
   }
 
-  registerEndpoint(method: string | symbol, ...data: Partial<EndpointConfig>[]): EndpointConfig {
+  registerEndpoint(method: string, ...data: Partial<EndpointConfig>[]): EndpointConfig {
     this.register();
 
     if (!this.#endpoints.has(method)) {
@@ -108,8 +108,8 @@ export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConf
         allowsBody: false,
         class: this.#cls,
         filters: [],
-        methodName: method.toString(),
-        id: `${this.#cls.name}#${method.toString()}`,
+        methodName: method,
+        id: `${this.#cls.name}#${method}`,
         parameters: [],
         interceptorConfigs: [],
         responseHeaders: {},
@@ -124,23 +124,23 @@ export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConf
     return this.#endpoints.get(method)!;
   }
 
-  registerEndpointParameter(method: string | symbol, idx: number, ...config: Partial<EndpointParameterConfig>[]): EndpointParameterConfig {
-    const ep = this.registerEndpoint(method);
-    ep.parameters[idx] ??= { index: idx, location: 'query' };
-    safeAssign(ep.parameters[idx], ...config);
-    return ep.parameters[idx];
+  registerEndpointParameter(method: string, idx: number, ...config: Partial<EndpointParameterConfig>[]): EndpointParameterConfig {
+    const endpoint = this.registerEndpoint(method);
+    endpoint.parameters[idx] ??= { index: idx, location: 'query' };
+    safeAssign(endpoint.parameters[idx], ...config);
+    return endpoint.parameters[idx];
   }
 
   finalize(): void {
     // Merge into controller
-    for (const ep of this.#config.endpoints) {
+    for (const endpoint of this.#config.endpoints) {
       // Store full path from base for use in other contexts
-      ep.fullPath = `/${this.#config.basePath}/${ep.path}`.replace(/[/]{1,4}/g, '/').replace(/(.)[/]$/, (_, a) => a);
-      ep.finalizedResponseHeaders = new WebHeaders({ ...this.#config.responseHeaders, ...ep.responseHeaders });
-      ep.responseContext = { ...this.#config.responseContext, ...ep.responseContext };
-      for (const schema of SchemaRegistryIndex.get(this.#cls).getMethod(ep.methodName).parameters) {
-        ep.parameters[schema.index!] ??= { index: schema.index!, location: undefined! };
-        ep.parameters[schema.index!].location ??= computeParameterLocation(ep, schema);
+      endpoint.fullPath = `/${this.#config.basePath}/${endpoint.path}`.replace(/[/]{1,4}/g, '/').replace(/(.)[/]$/, (_, a) => a);
+      endpoint.finalizedResponseHeaders = new WebHeaders({ ...this.#config.responseHeaders, ...endpoint.responseHeaders });
+      endpoint.responseContext = { ...this.#config.responseContext, ...endpoint.responseContext };
+      for (const schema of SchemaRegistryIndex.get(this.#cls).getMethod(endpoint.methodName).parameters) {
+        endpoint.parameters[schema.index!] ??= { index: schema.index!, location: undefined! };
+        endpoint.parameters[schema.index!].location ??= computeParameterLocation(endpoint, schema);
       }
     }
     for (const item of this.#finalizeHandlers) {
@@ -153,7 +153,7 @@ export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConf
     return this.#config;
   }
 
-  getEndpointConfig(method: string | symbol): EndpointConfig {
+  getEndpointConfig(method: string): EndpointConfig {
     const endpoint = this.#endpoints.get(method);
     if (!endpoint) {
       throw new AppError(`Endpoint not registered: ${String(method)} on ${this.#cls.name}`);
@@ -170,7 +170,7 @@ export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConf
   }
 
   registerEndpointInterceptorConfig<T extends WebInterceptor>(
-    property: string | symbol,
+    property: string,
     cls: Class<T>,
     config: Partial<RetainPrimitiveFields<T['config']>>,
     extra?: Partial<EndpointConfig>

package/src/registry/registry-index.ts

@@ -37,19 +37,19 @@ export class ControllerRegistryIndex implements RegistryIndex {
   /**
    * Register a controller/endpoint with specific config for an interceptor
    * @param cls The interceptor to register data for
-   * @param cfg The partial config override
+   * @param config The partial config override
    */
   static createInterceptorConfigDecorator<T extends WebInterceptor>(
     cls: Class<T>,
-    cfg: Partial<RetainPrimitiveFields<T['config']>>,
+    config: Partial<RetainPrimitiveFields<T['config']>>,
     extra?: Partial<EndpointConfig & ControllerConfig>
   ): EndpointDecorator {
-    return (instanceOrCls: Class | ClassInstance, property?: symbol | string): void => {
+    return (instanceOrCls: Class | ClassInstance, property?: string): void => {
       const adapter = ControllerRegistryIndex.getForRegister(getClass(instanceOrCls));
       if (isClass(property, instanceOrCls)) {
-        adapter.registerInterceptorConfig(cls, cfg, extra);
+        adapter.registerInterceptorConfig(cls, config, extra);
       } else {
-        adapter.registerEndpointInterceptorConfig(property!, cls, cfg, extra);
+        adapter.registerEndpointInterceptorConfig(property!, cls, config, extra);
       }
     };
   }
@@ -85,8 +85,8 @@ export class ControllerRegistryIndex implements RegistryIndex {
     return this.store.get(cls).get();
   }
 
-  getEndpoint(cls: Class, method: string | symbol): EndpointConfig {
-    return this.getController(cls).endpoints.find(e => e.methodName === method)!;
+  getEndpoint(cls: Class, method: string): EndpointConfig {
+    return this.getController(cls).endpoints.find(endpoint => endpoint.methodName === method)!;
   }
 
   getEndpointById(id: string): EndpointConfig | undefined {
@@ -94,16 +94,16 @@ export class ControllerRegistryIndex implements RegistryIndex {
   }
 
   process(events: ChangeEvent<Class>[]): void {
-    for (const evt of events) {
-      if ('curr' in evt) {
-        for (const ep of this.getController(evt.curr).endpoints) {
-          this.#endpointsById.set(`${evt.curr.name}#${ep.methodName.toString()}`, ep);
+    for (const event of events) {
+      if ('current' in event) {
+        for (const endpoint of this.getController(event.current).endpoints) {
+          this.#endpointsById.set(`${event.current.name}#${endpoint.methodName}`, endpoint);
         }
       } else {
         // Match by name
-        const toDelete = [...this.#endpointsById.values()].filter(x => x.class.name === evt.prev.name);
-        for (const ep of toDelete) {
-          this.#endpointsById.delete(ep.id);
+        const toDelete = [...this.#endpointsById.values()].filter(endpoint => endpoint.class.name === event.previous.name);
+        for (const endpoint of toDelete) {
+          this.#endpointsById.delete(endpoint.id);
         }
       }
     }

package/src/registry/types.ts

@@ -16,7 +16,7 @@ export type EndpointFunctionDescriptor = TypedPropertyDescriptor<EndpointFunctio
  */
 export type EndpointDecorator = (
   (<T extends Class>(target: T) => void) &
-  (<U>(target: U, prop: string | symbol, descriptor?: EndpointFunctionDescriptor) => void)
+  (<U>(target: U, property: string, descriptor?: EndpointFunctionDescriptor) => void)
 );
 
 export type EndpointParamLocation = 'path' | 'query' | 'body' | 'header';
@@ -48,7 +48,7 @@ interface CoreConfig {
   /**
    * Control which interceptors are excluded
    */
-  interceptorExclude?: (val: WebInterceptor) => boolean;
+  interceptorExclude?: (value: WebInterceptor) => boolean;
   /**
    * Response headers
    */
@@ -72,7 +72,7 @@ export interface EndpointParameterConfig {
    */
   location: EndpointParamLocation;
   /**
-   * Resolves the value by executing with req/res as input
+   * Resolves the value by executing with request/response as input
    */
   resolve?: WebFilter;
   /**
@@ -97,7 +97,7 @@ export interface EndpointConfig extends CoreConfig {
   /**
    * Name of the endpoint (method name)
    */
-  methodName: string | symbol;
+  methodName: string;
   /**
    * Instance the endpoint is for
    */
@@ -133,7 +133,7 @@ export interface EndpointConfig extends CoreConfig {
   /**
    * Response finalizer
    */
-  responseFinalizer?: (res: WebResponse) => WebResponse;
+  responseFinalizer?: (response: WebResponse) => WebResponse;
   /**
    * Response headers finalized
    */
@@ -159,7 +159,7 @@ export interface ControllerConfig extends CoreConfig {
   /**
    * Context parameters to bind at create
    */
-  contextParams: Record<string | symbol, boolean>;
+  contextParams: Record<string, boolean>;
 }
 
 /**

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 = {