@travetto/web 7.0.0-rc.1 → 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> = {});
 }
 ```
 
@@ -155,10 +155,10 @@ class SimpleController {
 
 ### Parameters
 Endpoints can be configured to describe and enforce parameter behavior.  Request parameters can be defined in five areas:
-   *  [@PathParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L38) - Path params
-   *  [@QueryParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L45) - Query params - can be either a single value or bind to a whole object
-   *  [@Body](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L59) - Request body
-   *  [@HeaderParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L52) - Header values
+   *  [@PathParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L36) - Path params
+   *  [@QueryParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L43) - Query params - can be either a single value or bind to a whole object
+   *  [@Body](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L57) - Request body
+   *  [@HeaderParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L50) - Header values
 
 Each [@Param](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L16) can be configured to indicate:
    *  `name` - Name of param, field name, defaults to handler parameter name if necessary
@@ -223,7 +223,7 @@ export class Simple {
 ```
 
 ### ContextParam
-In addition to endpoint parameters (i.e. user-provided inputs), there may also be a desire to access indirect contextual information.  Specifically you may need access to the entire [WebRequest](https://github.com/travetto/travetto/tree/main/module/web/src/types/request.ts#L11).  These are able to be injected using the [@ContextParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L66) on a class-level field from the [WebAsyncContext](https://github.com/travetto/travetto/tree/main/module/web/src/context.ts#L11).  These are not exposed as endpoint parameters as they cannot be provided when making RPC invocations.
+In addition to endpoint parameters (i.e. user-provided inputs), there may also be a desire to access indirect contextual information.  Specifically you may need access to the entire [WebRequest](https://github.com/travetto/travetto/tree/main/module/web/src/types/request.ts#L11).  These are able to be injected using the [@ContextParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L64) on a class-level field from the [WebAsyncContext](https://github.com/travetto/travetto/tree/main/module/web/src/context.ts#L11).  These are not exposed as endpoint parameters as they cannot be provided when making RPC invocations.
 
 **Code: Example ContextParam usage**
 ```typescript
@@ -251,12 +251,12 @@ class ContextController {
 }
 ```
 
-**Note**: When referencing the [@ContextParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L66) values, the contract for idempotency needs to be carefully inspected, if expected. You can see in the example above that the [@CacheControl](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/common.ts#L45) decorator is used to ensure that the response is not cached.
+**Note**: When referencing the [@ContextParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L64) values, the contract for idempotency needs to be carefully inspected, if expected. You can see in the example above that the [@CacheControl](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/common.ts#L45) decorator is used to ensure that the response is not cached.
 
 ### Validating Inputs
 The module provides high level access for [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.") support, via decorators, for validating and typing request inputs. 
 
-By default, all endpoint parameters are validated for type, and any additional constraints added (required, vs optional, minlength, etc).  Each parameter location ([@PathParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L38), [@Body](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L59), [@QueryParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L45), [@HeaderParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L52)) primarily provides a source to bind the endpoint arguments from.  Once bound, the module will validate that the provided arguments are in fact valid. All validation will occur before the endpoint is ever executed, ensuring a strong contract.
+By default, all endpoint parameters are validated for type, and any additional constraints added (required, vs optional, minlength, etc).  Each parameter location ([@PathParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L36), [@Body](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L57), [@QueryParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L43), [@HeaderParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L50)) primarily provides a source to bind the endpoint arguments from.  Once bound, the module will validate that the provided arguments are in fact valid. All validation will occur before the endpoint is ever executed, ensuring a strong contract.
 
 **Code: Using Body for POST requests**
 ```typescript
@@ -667,7 +667,7 @@ export class AlowDenyController {
   }
 
   @Get('/raw')
-  @ExcludeInterceptors(v => v.category === 'response')
+  @ExcludeInterceptors(({ category }) => category === 'response')
   withoutResponse(@QueryParam() value: string) {
 
   }
@@ -735,15 +735,15 @@ export class SimpleAuthInterceptor implements WebInterceptor {
 ```
 
 ## Cookie Support
-Cookies are a unique element, within the framework, as they sit on the request and response flows.  Ideally we would separate these out, but given the support for key rotation, there is a scenario in which reading a cookie on the request, will result in a cookie needing to be written on the response.  Because of this, cookies are treated as being outside the normal [WebRequest](https://github.com/travetto/travetto/tree/main/module/web/src/types/request.ts#L11) activity, and is exposed as the [@ContextParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L66) [CookieJar](https://github.com/travetto/travetto/tree/main/module/web/src/util/cookie.ts#L12).  The [CookieJar](https://github.com/travetto/travetto/tree/main/module/web/src/util/cookie.ts#L12) has a fairly basic contract:
+Cookies are a unique element, within the framework, as they sit on the request and response flows.  Ideally we would separate these out, but given the support for key rotation, there is a scenario in which reading a cookie on the request, will result in a cookie needing to be written on the response.  Because of this, cookies are treated as being outside the normal [WebRequest](https://github.com/travetto/travetto/tree/main/module/web/src/types/request.ts#L11) activity, and is exposed as the [@ContextParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L64) [CookieJar](https://github.com/travetto/travetto/tree/main/module/web/src/util/cookie.ts#L12).  The [CookieJar](https://github.com/travetto/travetto/tree/main/module/web/src/util/cookie.ts#L12) has a fairly basic contract:
 
 **Code: CookieJar contract**
 ```typescript
 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.1",
+  "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.0",
-    "@travetto/context": "^7.0.0-rc.0",
-    "@travetto/di": "^7.0.0-rc.0",
-    "@travetto/registry": "^7.0.0-rc.0",
-    "@travetto/runtime": "^7.0.0-rc.0",
-    "@travetto/schema": "^7.0.0-rc.0",
+    "@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.0",
-    "@travetto/test": "^7.0.0-rc.0",
-    "@travetto/transformer": "^7.0.0-rc.0"
+    "@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
@@ -13,50 +13,48 @@ type ParamDecorator = (instance: ClassInstance, property: string | symbol, idx:
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Param(location: EndpointParamLocation, extra: string | Partial<EndpointParameterConfig>): ParamDecorator {
-  return (instance: ClassInstance, property: string | symbol, idx: number): void => {
-    const name = typeof extra === 'string' ? extra : extra.name;
-    const config = typeof extra === 'string' ? {} : extra;
-
-    // Set name as needed
-    if (name) {
-      SchemaRegistryIndex.getForRegister(getClass(instance)).registerParameter(property, idx, { name });
+export function Param(location: EndpointParamLocation, aliasOrConfig: string | Partial<EndpointParameterConfig>): ParamDecorator {
+  return (instance: ClassInstance, property: string, idx: number): void => {
+    const config = typeof aliasOrConfig === 'string' ? {} : aliasOrConfig;
+    const cls = getClass(instance);
+    if (typeof aliasOrConfig === 'string') {
+      SchemaRegistryIndex.getForRegister(cls).registerParameter(property, idx, {
+        aliases: [aliasOrConfig] // Register extra input string as an alias
+      });
     }
 
-    ControllerRegistryIndex.getForRegister(getClass(instance)).registerEndpointParameter(property, idx, {
-      index: idx, location, ...config
-    });
+    ControllerRegistryIndex.getForRegister(cls).registerEndpointParameter(property, idx, { location, ...config });
   };
 }
 
 /**
  * Define a Path param
- * @param param The param configuration or name
+ * @input input The param configuration or alias
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function PathParam(param: string | Partial<EndpointParameterConfig> = {}): ParamDecorator { return Param('path', param); }
+export function PathParam(input: string | Partial<EndpointParameterConfig> = {}): ParamDecorator { return Param('path', input); }
 /**
  * Define a Query param
- * @param param The param configuration or name
+ * @input input The param configuration or alias
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function QueryParam(param: string | Partial<EndpointParameterConfig> = {}): ParamDecorator { return Param('query', param); }
+export function QueryParam(input: string | Partial<EndpointParameterConfig> = {}): ParamDecorator { return Param('query', input); }
 /**
  * Define a Header param
- * @param param The param configuration or name
+ * @input input The param configuration or alias
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function HeaderParam(param: string | Partial<EndpointParameterConfig> = {}): ParamDecorator { return Param('header', param); }
+export function HeaderParam(input: string | Partial<EndpointParameterConfig> = {}): ParamDecorator { return Param('header', input); }
 /**
  * Define a body param as an input
- * @param param The param configuration
+ * @input input The param configuration
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Body(param: Partial<EndpointParameterConfig> = {}): ParamDecorator { return Param('body', param); }
+export function Body(input: Partial<EndpointParameterConfig> = {}): ParamDecorator { return Param('body', input); }
 
 /**
  * A contextual field as provided by the WebAsyncContext
@@ -64,7 +62,7 @@ export function Body(param: 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, index: number, ...config: Partial<EndpointParameterConfig>[]): EndpointParameterConfig {
-    const ep = this.registerEndpoint(method);
-    ep.parameters[index] ??= { index, location: 'query' };
-    safeAssign(ep.parameters[index], ...config);
-    return ep.parameters[index];
+  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.getMethodConfig(this.#cls, 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);
       }
     };
   }
@@ -62,8 +62,9 @@ export class ControllerRegistryIndex implements RegistryIndex {
     const ctx = await DependencyRegistryIndex.getInstance(WebAsyncContext);
     const cls = getClass(instance);
     const map = this.getController(cls).contextParams;
+    const fieldMap = SchemaRegistryIndex.get(cls).getFields();
     for (const field of Object.keys(map)) {
-      const { type } = SchemaRegistryIndex.getFieldMap(cls)[field];
+      const { type } = fieldMap[field];
       Object.defineProperty(instance, field, { get: ctx.getSource(type) });
     }
   }
@@ -84,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 {
@@ -93,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>;
 }
 
 /**