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

package/README.md

@@ -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
@@ -735,7 +735,7 @@ 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/web",
-  "version": "7.0.0-rc.0",
+  "version": "7.0.0-rc.2",
   "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.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",
     "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.1",
+    "@travetto/test": "^7.0.0-rc.1",
+    "@travetto/transformer": "^7.0.0-rc.1"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/decorator/param.ts

@@ -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 {
+export function Param(location: EndpointParamLocation, aliasOrConfig: 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 });
+    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

package/src/registry/registry-adapter.ts

@@ -108,7 +108,6 @@ export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConf
         allowsBody: false,
         class: this.#cls,
         filters: [],
-        endpoint: this.#cls.prototype[method],
         methodName: method.toString(),
         id: `${this.#cls.name}#${method.toString()}`,
         parameters: [],
@@ -125,11 +124,11 @@ export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConf
     return this.#endpoints.get(method)!;
   }
 
-  registerEndpointParameter(method: string | symbol, index: number, ...config: Partial<EndpointParameterConfig>[]): EndpointParameterConfig {
+  registerEndpointParameter(method: string | symbol, idx: 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];
+    ep.parameters[idx] ??= { index: idx, location: 'query' };
+    safeAssign(ep.parameters[idx], ...config);
+    return ep.parameters[idx];
   }
 
   finalize(): void {
@@ -139,7 +138,7 @@ export class ControllerRegistryAdapter implements RegistryAdapter<ControllerConf
       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) {
+      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);
       }

package/src/registry/registry-index.ts

@@ -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) });
     }
   }

package/src/registry/types.ts

@@ -118,10 +118,6 @@ export interface EndpointConfig extends CoreConfig {
    * The path of the endpoint
    */
   path: string;
-  /**
-   * The function the endpoint will call
-   */
-  endpoint: EndpointFunction;
   /**
    * The compiled and finalized handler
    */

package/src/registry/visitor.ts

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

package/src/util/endpoint.ts

@@ -1,4 +1,4 @@
-import { asConstructable, castTo, Class, Runtime, TypedObject } from '@travetto/runtime';
+import { asConstructable, castKey, castTo, Class, Runtime, TypedObject } from '@travetto/runtime';
 import { BindUtil, SchemaParameterConfig, SchemaRegistryIndex, SchemaValidator, ValidationResultError } from '@travetto/schema';
 import { DependencyRegistryIndex } from '@travetto/di';
 import { RetargettingProxy } from '@travetto/registry';
@@ -8,7 +8,7 @@ import { WebResponse } from '../types/response.ts';
 import { WebInterceptor } from '../types/interceptor.ts';
 import { WebRequest } from '../types/request.ts';
 import { WEB_INTERCEPTOR_CATEGORIES } from '../types/core.ts';
-import { EndpointConfig, ControllerConfig, EndpointParameterConfig } from '../registry/types.ts';
+import { EndpointConfig, ControllerConfig, EndpointParameterConfig, EndpointFunction } from '../registry/types.ts';
 import { ControllerRegistryIndex } from '../registry/registry-index.ts';
 import { WebCommonUtil } from './common.ts';
 
@@ -122,14 +122,9 @@ export class EndpointUtil {
       }
     }
 
-    let res = this.extractParameterValue(request, param, input.name!.toString(), input.array);
-    if (!res && input.aliases) {
-      for (const name of input.aliases) {
-        res = this.extractParameterValue(request, param, name, input.array);
-        if (res !== undefined) {
-          break;
-        }
-      }
+    let 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;
     }
     return res;
   }
@@ -143,7 +138,7 @@ export class EndpointUtil {
   static async extractParameters(endpoint: EndpointConfig, request: WebRequest): Promise<unknown[]> {
     const cls = endpoint.class;
     const vals = WebCommonUtil.getRequestParams(request);
-    const { parameters } = SchemaRegistryIndex.getMethodConfig(cls, endpoint.methodName);
+    const { parameters } = SchemaRegistryIndex.get(cls).getMethod(endpoint.methodName);
     const combined = parameters.map((cfg) =>
       ({ schema: cfg, param: endpoint.parameters[cfg.index], value: vals?.[cfg.index] }));
 
@@ -177,7 +172,7 @@ export class EndpointUtil {
   static async invokeEndpoint(endpoint: EndpointConfig, { request }: WebChainedContext): Promise<WebResponse> {
     try {
       const params = await this.extractParameters(endpoint, request);
-      const body = await endpoint.endpoint.apply(endpoint.instance, params);
+      const body = await castTo<EndpointFunction>(endpoint.instance![castKey(endpoint.methodName)]).apply(endpoint.instance, params);
       const headers = endpoint.finalizedResponseHeaders;
       let response: WebResponse;
       if (body instanceof WebResponse) {

package/support/test/suite/schema.ts

@@ -110,7 +110,7 @@ function getEndpoint(path: string, method: HttpMethod) {
 
 function getEndpointResponse(path: string, method: HttpMethod) {
   const ep = getEndpoint(path, method);
-  const resp = SchemaRegistryIndex.getMethodConfig(SchemaAPI, ep.methodName);
+  const resp = SchemaRegistryIndex.get(SchemaAPI).getMethod(ep.methodName);
   return resp?.returnType?.type;
 }