@travetto/web 6.0.2 → 7.0.0-rc.0

package/README.md

@@ -2,7 +2,7 @@
 <!-- Please modify https://github.com/travetto/travetto/tree/main/module/web/DOC.tsx and execute "npx trv doc" to rebuild -->
 # Web API
 
-## Declarative support creating for Web Applications
+## Declarative support for creating Web Applications
 
 **Install: @travetto/web**
 ```bash
@@ -13,9 +13,9 @@ npm install @travetto/web
 yarn add @travetto/web
 ```
 
-The module provides a declarative API for creating and describing a Web application.  Since the framework is declarative, decorators are used to configure almost everything. The general layout of an application is a collection of [@Controller](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/controller.ts#L9)s that employ some combination of [WebInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/types/interceptor.ts#L15)s to help manage which functionality is executed before the [Endpoint](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L14) code, within the [@Controller](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/controller.ts#L9). This module will look at:
+The module provides a declarative API for creating and describing a Web application.  Since the framework is declarative, decorators are used to configure almost everything. The general layout of an application is a collection of [@Controller](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/controller.ts#L11)s that employ some combination of [WebInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/types/interceptor.ts#L15)s to help manage which functionality is executed before the [Endpoint](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L14) code, within the [@Controller](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/controller.ts#L11). This module will look at:
    *  Request/Response Pattern
-   *  Defining a [@Controller](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/controller.ts#L9)
+   *  Defining a [@Controller](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/controller.ts#L11)
    *  Defining an [Endpoint](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L14)
    *  Using a [WebInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/types/interceptor.ts#L15)
    *  Creating a Custom [WebInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/types/interceptor.ts#L15)
@@ -91,7 +91,7 @@ export class WebResponse<B = unknown> extends BaseWebMessage<B, WebResponseConte
 These objects do not represent the underlying sockets provided by various http servers, but in fact are simple wrappers that track the flow through the call stack of the various [WebInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/types/interceptor.ts#L15)s and the [Endpoint](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L14) handler.  One of the biggest departures here, is that the response is not an entity that is passed around from call-site to call-site, but is is solely a return-value.  This doesn't mean the return value has to be static and pre-allocated, on the contrary streams are still supported.  The difference here is that the streams/asynchronous values will be consumed until the response is sent back to the user. The [CompressInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/compress.ts#L44) is a good reference for transforming a [WebResponse](https://github.com/travetto/travetto/tree/main/module/web/src/types/response.ts#L3) that can either be a stream or a fixed value.
 
 ## Defining a Controller
-To start, we must define a [@Controller](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/controller.ts#L9), which is only allowed on classes. Controllers can be configured with:
+To start, we must define a [@Controller](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/controller.ts#L11), which is only allowed on classes. Controllers can be configured with:
    *  `path` - The required context path the controller will operate atop
    *  `title` - The definition of the controller
    *  `description` - High level description fo the controller
@@ -114,13 +114,13 @@ class SimpleController {
 Once the controller is declared, each method of the controller is a candidate for being an endpoint.  By design, everything is asynchronous, and so async/await is natively supported. 
 
 The most common pattern is to register HTTP-driven endpoints.  The HTTP methods that are currently supported:
-   *  [@Get](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L42)
-   *  [@Post](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L49)
-   *  [@Put](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L56)
+   *  [@Get](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L41)
+   *  [@Post](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L48)
+   *  [@Put](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L55)
    *  [@Delete](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L69)
-   *  [@Patch](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L63)
-   *  [@Head](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L75)
-   *  [@Options](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L81)
+   *  [@Patch](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L62)
+   *  [@Head](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L76)
+   *  [@Options](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L83)
 
 Similar to the Controller, each endpoint decorator handles the following config:
    *  `title` - The definition of the endpoint
@@ -155,12 +155,12 @@ 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#L37) - 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#L55) - Request body
-   *  [@HeaderParam](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L49) - Header values
+   *  [@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
 
-Each [@Param](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L24) can be configured to indicate:
+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
    *  `description` - Description of param, pulled from [JSDoc](http://usejsdoc.org/about-getting-started.html), or defaults to name if empty
    *  `required?` - Is the field required?, defaults to whether or not the parameter itself is optional
@@ -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#L61) 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#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.
 
 **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#L61) 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#L48) 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#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.
 
 ### 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#L37), [@Body](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/param.ts#L55), [@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#L49)) 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#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.
 
 **Code: Using Body for POST requests**
 ```typescript
@@ -617,7 +617,7 @@ export class CorsConfig {
 ```
 
 #### CacheControlInterceptor
-[CacheControlInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/cache-control.ts#L23) by default, enforces whatever caching policy is established on a given endpoint using the [CacheControl](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/common.ts#L48) decorator.   Additionally, the interceptor retains knowledge if it is running on a private endpoint, or not.  If the endpoint is deemed private it affects the caching header accordingly. If the endpoint directly returns a `Cache-Control` header, that takes precedence and all other logic is ignored. 
+[CacheControlInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/interceptor/cache-control.ts#L23) by default, enforces whatever caching policy is established on a given endpoint using the [@CacheControl](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/common.ts#L45) decorator.   Additionally, the interceptor retains knowledge if it is running on a private endpoint, or not.  If the endpoint is deemed private it affects the caching header accordingly. If the endpoint directly returns a `Cache-Control` header, that takes precedence and all other logic is ignored. 
 
 This can be managed by setting `web.cache.applies: <boolean>` in your config. 
 
@@ -675,11 +675,11 @@ export class AlowDenyController {
 ```
 
 The resolution logic is as follows:
-   *  Check the resolved [Endpoint](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L14)/[@Controller](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/controller.ts#L9) overrides to see if an interceptor is explicitly allowed or disallowed
+   *  Check the resolved [Endpoint](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/endpoint.ts#L14)/[@Controller](https://github.com/travetto/travetto/tree/main/module/web/src/decorator/controller.ts#L11) overrides to see if an interceptor is explicitly allowed or disallowed
    *  Default to `applies()` logic for all available interceptors
 
 ## Creating a Custom WebInterceptor
-Additionally it may be desirable to create a custom interceptor.  Interceptors can be registered with the [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.") by implementing the [WebInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/types/interceptor.ts#L15) interface and adding an [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) decorator. A simple logging interceptor:
+Additionally it may be desirable to create a custom interceptor.  Interceptors can be registered with the [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.") by implementing the [WebInterceptor](https://github.com/travetto/travetto/tree/main/module/web/src/types/interceptor.ts#L15) interface and adding an [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L15) decorator. A simple logging interceptor:
 
 **Code: Defining a new Interceptor**
 ```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#L61) [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#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:
 
 **Code: CookieJar contract**
 ```typescript

package/__index__.ts

@@ -19,7 +19,8 @@ export * from './src/decorator/controller.ts';
 export * from './src/decorator/param.ts';
 export * from './src/decorator/endpoint.ts';
 
-export * from './src/registry/controller.ts';
+export * from './src/registry/registry-index.ts';
+export * from './src/registry/registry-adapter.ts';
 export * from './src/registry/visitor.ts';
 export * from './src/registry/types.ts';
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/web",
-  "version": "6.0.2",
-  "description": "Declarative support creating for Web Applications",
+  "version": "7.0.0-rc.0",
+  "description": "Declarative support for creating Web Applications",
   "keywords": [
     "web",
     "decorators",
@@ -25,18 +25,18 @@
     "directory": "module/web"
   },
   "dependencies": {
-    "@travetto/config": "^6.0.0",
-    "@travetto/context": "^6.0.0",
-    "@travetto/di": "^6.0.0",
-    "@travetto/registry": "^6.0.0",
-    "@travetto/runtime": "^6.0.0",
-    "@travetto/schema": "^6.0.0",
+    "@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",
     "find-my-way": "^9.3.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^6.0.0",
-    "@travetto/test": "^6.0.1",
-    "@travetto/transformer": "^6.0.0"
+    "@travetto/cli": "^7.0.0-rc.0",
+    "@travetto/test": "^7.0.0-rc.0",
+    "@travetto/transformer": "^7.0.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/common/global.ts

@@ -1,20 +1,21 @@
-import { DependencyRegistry } from '@travetto/di';
+import { DependencyRegistryIndex } from '@travetto/di';
 import { Runtime } from '@travetto/runtime';
+import { IsPrivate } from '@travetto/schema';
 
 import { Controller } from '../decorator/controller.ts';
-import { ConditionalRegister, ConfigureInterceptor, Undocumented } from '../decorator/common.ts';
+import { ConditionalRegister, ConfigureInterceptor } from '../decorator/common.ts';
 import { Get, Options } from '../decorator/endpoint.ts';
 import { WebConfig } from '../config.ts';
 import { LoggingInterceptor, } from '../interceptor/logging.ts';
 
-@Undocumented()
+@IsPrivate()
 @Controller('/')
 @ConfigureInterceptor(LoggingInterceptor, { applies: false })
 export class GlobalHandler {
 
   @Get('')
   @ConditionalRegister(async () => {
-    const config = await DependencyRegistry.getInstance(WebConfig);
+    const config = await DependencyRegistryIndex.getInstance(WebConfig);
     return config.defaultMessage;
   })
   message(): { module: string, version: string, env?: string } {

package/src/decorator/common.ts

@@ -1,34 +1,29 @@
-import { asConstructable, castTo, Class, TimeSpan, TimeUtil } from '@travetto/runtime';
+import { Class, ClassInstance, getClass, RetainPrimitiveFields, TimeSpan, TimeUtil } from '@travetto/runtime';
 
-import { ControllerRegistry } from '../registry/controller.ts';
-import { EndpointConfig, ControllerConfig, DescribableConfig, EndpointDecorator, EndpointFunctionDescriptor } from '../registry/types.ts';
+import { ControllerRegistryIndex } from '../registry/registry-index.ts';
+import { EndpointConfig, ControllerConfig, EndpointDecorator, EndpointFunctionDescriptor } from '../registry/types.ts';
 import { AcceptInterceptor } from '../interceptor/accept.ts';
 import { WebInterceptor } from '../types/interceptor.ts';
 
+function isClass(target: unknown, property: unknown,): target is Class<unknown> {
+  return !property;
+}
+
 function register(config: Partial<EndpointConfig | ControllerConfig>): EndpointDecorator {
-  return function <T>(target: T | Class<T>, property?: string, descriptor?: EndpointFunctionDescriptor) {
-    if (descriptor) {
-      return ControllerRegistry.registerPendingEndpoint(asConstructable(target).constructor, descriptor, config);
+  return function <T>(instanceOrCls: ClassInstance | Class<T>, property?: string | symbol, _?: EndpointFunctionDescriptor) {
+    const adapter = ControllerRegistryIndex.getForRegister(getClass(instanceOrCls));
+    if (isClass(instanceOrCls, property)) {
+      adapter.register(config);
     } else {
-      return ControllerRegistry.registerPending(castTo(target), config);
+      adapter.registerEndpoint(property!, config);
     }
   };
 }
 
-/**
- * Decorator used to add description metadata to a class or method
- * @param desc The describe config
- */
-export function Describe(desc: DescribableConfig): EndpointDecorator { return register(desc); }
-
-/**
- * Marks a class/endpoint as being undocumented
- */
-export function Undocumented(): EndpointDecorator { return register({ documented: false }); }
-
 /**
  * Set response headers on success
  * @param headers The response headers to set
+ * @kind decorator
  */
 export function SetHeaders(headers: EndpointConfig['responseHeaders']): EndpointDecorator {
   return register({ responseHeaders: headers });
@@ -36,6 +31,7 @@ export function SetHeaders(headers: EndpointConfig['responseHeaders']): Endpoint
 
 /**
  * Specifies content type for response
+ * @kind decorator
  */
 export function Produces(mime: string): EndpointDecorator { return SetHeaders({ 'Content-Type': mime }); }
 
@@ -44,6 +40,7 @@ type CacheControlInput = { cacheableAge?: number | TimeSpan, isPrivate?: boolean
 /**
  * Set the max-age of a response based on the config
  * @param value The value for the duration
+ * @kind decorator
  */
 export function CacheControl(input: TimeSpan | number | CacheControlInput, extra?: Omit<CacheControlInput, 'cacheableAge'>): EndpointDecorator {
   if (typeof input === 'string' || typeof input === 'number') {
@@ -61,9 +58,10 @@ export function CacheControl(input: TimeSpan | number | CacheControlInput, extra
 /**
  * Define an endpoint to support specific input types
  * @param types The list of mime types to allow/deny
+ * @kind decorator
  */
 export function Accepts(types: [string, ...string[]]): EndpointDecorator {
-  return ControllerRegistry.createInterceptorConfigDecorator(
+  return ControllerRegistryIndex.createInterceptorConfigDecorator(
     AcceptInterceptor,
     { types, applies: true },
     { responseHeaders: { accepts: types.join(', ') } }
@@ -72,12 +70,18 @@ export function Accepts(types: [string, ...string[]]): EndpointDecorator {
 
 /**
  * Allows for configuring interceptor-level support at an endpoint or controller level
+ * @kind decorator
  */
-export const ConfigureInterceptor =
-  ControllerRegistry.createInterceptorConfigDecorator.bind(ControllerRegistry);
+export const ConfigureInterceptor = <T extends WebInterceptor>(
+  cls: Class<T>,
+  cfg: Partial<RetainPrimitiveFields<T['config']>>,
+  extra?: Partial<EndpointConfig & ControllerConfig>
+): EndpointDecorator =>
+  ControllerRegistryIndex.createInterceptorConfigDecorator(cls, cfg, extra);
 
 /**
  * Specifies if endpoint should be conditional
+ * @kind decorator
  */
 export function ConditionalRegister(handler: () => (boolean | Promise<boolean>)): EndpointDecorator {
   return register({ conditional: handler });
@@ -85,6 +89,7 @@ export function ConditionalRegister(handler: () => (boolean | Promise<boolean>))
 
 /**
  * Registers an interceptor exclusion filter
+ * @kind decorator
  */
 export function ExcludeInterceptors(interceptorExclude: (val: WebInterceptor) => boolean): EndpointDecorator {
   return register({ interceptorExclude });

package/src/decorator/controller.ts

@@ -1,13 +1,16 @@
 import { Class } from '@travetto/runtime';
-import { ControllerRegistry } from '../registry/controller.ts';
+import { DependencyRegistryIndex } from '@travetto/di';
+
+import { ControllerRegistryIndex } from '../registry/registry-index.ts';
 
 /**
  * Decorator to register a new web controller
- * @augments `@travetto/di:Injectable`
- * @augments `@travetto/web:Controller`
+ * @augments `@travetto/schema:Schema`
+ * @kind decorator
  */
 export function Controller(path: string) {
-  return function <T>(target: Class<T>): void {
-    ControllerRegistry.registerPending(target, { basePath: path, class: target, });
+  return function <T>(cls: Class<T>): void {
+    ControllerRegistryIndex.getForRegister(cls).register({ basePath: path, class: cls, });
+    DependencyRegistryIndex.getForRegister(cls).registerClass();
   };
 }

package/src/decorator/endpoint.ts

@@ -1,10 +1,10 @@
-import { asConstructable } from '@travetto/runtime';
+import { ClassInstance, getClass } from '@travetto/runtime';
 
-import { ControllerRegistry } from '../registry/controller.ts';
-import { EndpointConfig, EndpointFunctionDescriptor, EndpointIOType } from '../registry/types.ts';
+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>(target: T, prop: symbol | string, descriptor: EndpointFunctionDescriptor) => EndpointFunctionDescriptor;
+type EndpointFunctionDecorator = <T>(instance: T, property: symbol | string, descriptor: EndpointFunctionDescriptor) => EndpointFunctionDescriptor;
 
 type EndpointDecConfig = Partial<EndpointConfig> & { path: string };
 
@@ -12,11 +12,9 @@ type EndpointDecConfig = Partial<EndpointConfig> & { path: string };
  * Generic Endpoint Decorator
  */
 export function Endpoint(config: EndpointDecConfig): EndpointFunctionDecorator {
-  return function <T>(target: T, prop: symbol | string, descriptor: EndpointFunctionDescriptor): EndpointFunctionDescriptor {
-    const result = ControllerRegistry.registerPendingEndpoint(
-      asConstructable(target).constructor, descriptor, config
-    );
-    return result;
+  return function (instance: ClassInstance, property: symbol | string, descriptor: EndpointFunctionDescriptor): EndpointFunctionDescriptor {
+    ControllerRegistryIndex.getForRegister(getClass(instance)).registerEndpoint(property, { methodName: property }, config);
+    return descriptor;
   };
 }
 
@@ -37,65 +35,49 @@ function HttpEndpoint(method: HttpMethod, path: string): EndpointFunctionDecorat
 /**
  * Registers GET requests
  * @param path The endpoint path for the request
- * @augments `@travetto/web:Endpoint`
+ * @augments `@travetto/schema:Method`
+ * @kind decorator
  */
 export function Get(path = '/'): EndpointFunctionDecorator { return HttpEndpoint('GET', path); }
 /**
  * Registers POST requests
  * @param path The endpoint path for the request
- * @augments `@travetto/web:HttpRequestBody`
- * @augments `@travetto/web:Endpoint`
+ * @augments `@travetto/schema:Method`
+ * @kind decorator
  */
 export function Post(path = '/'): EndpointFunctionDecorator { return HttpEndpoint('POST', path); }
 /**
  * Registers PUT requests
  * @param path The endpoint path for the request
- * @augments `@travetto/web:HttpRequestBody`
- * @augments `@travetto/web:Endpoint`
+ * @augments `@travetto/schema:Method`
+ * @kind decorator
  */
 export function Put(path = '/'): EndpointFunctionDecorator { return HttpEndpoint('PUT', path); }
 /**
  * Registers PATCH requests
  * @param path The endpoint path for the request
- * @augments `@travetto/web:HttpRequestBody`
- * @augments `@travetto/web:Endpoint`
+ * @augments `@travetto/schema:Method`
+ * @kind decorator
  */
 export function Patch(path = '/'): EndpointFunctionDecorator { return HttpEndpoint('PATCH', path); }
 /**
  * Registers DELETE requests
  * @param path The endpoint path for the request
- * @augments `@travetto/web:Endpoint`
+ * @augments `@travetto/schema:Method`
+ * @kind decorator
  */
 export function Delete(path = '/'): EndpointFunctionDecorator { return HttpEndpoint('DELETE', path); }
 /**
  * Registers HEAD requests
  * @param path The endpoint path for the request
- * @augments `@travetto/web:Endpoint`
+ * @augments `@travetto/schema:Method`
+ * @kind decorator
  */
 export function Head(path = '/'): EndpointFunctionDecorator { return HttpEndpoint('HEAD', path); }
 /**
  * Registers OPTIONS requests
  * @param path The endpoint path for the request
- * @augments `@travetto/web:Endpoint`
+ * @augments `@travetto/schema:Method`
+ * @kind decorator
  */
 export function Options(path = '/'): EndpointFunctionDecorator { return HttpEndpoint('OPTIONS', path); }
-
-/**
- * Defines the response type of the endpoint
- * @param responseType The desired response mime type
- */
-export function ResponseType(responseType: EndpointIOType): EndpointFunctionDecorator {
-  return function <T>(target: T, property: string | symbol, descriptor: EndpointFunctionDescriptor) {
-    return ControllerRegistry.registerPendingEndpoint(asConstructable(target).constructor, descriptor, { responseType });
-  };
-}
-
-/**
- * Defines the supported request body type
- * @param requestType The type of the request body
- */
-export function RequestType(requestType: EndpointIOType): EndpointFunctionDecorator {
-  return function <T>(target: T, property: string | symbol, descriptor: EndpointFunctionDescriptor) {
-    return ControllerRegistry.registerPendingEndpoint(asConstructable(target).constructor, descriptor, { requestType });
-  };
-}

package/src/decorator/param.ts

@@ -1,64 +1,71 @@
-import { asConstructable, Class, ClassInstance } from '@travetto/runtime';
+import { ClassInstance, getClass } from '@travetto/runtime';
+import { SchemaRegistryIndex } from '@travetto/schema';
 
-import { ControllerRegistry } from '../registry/controller.ts';
-import { EndpointParamConfig } from '../registry/types.ts';
+import { ControllerRegistryIndex } from '../registry/registry-index.ts';
+import { EndpointParameterConfig, EndpointParamLocation } from '../registry/types.ts';
 
-type ParamDecorator = (target: ClassInstance, propertyKey: string | symbol, idx: number) => void;
-
-/**
- * Get the param configuration
- * @param location The location of the parameter
- * @param extra Any additional configuration for the param config
- */
-export const paramConfig = (location: EndpointParamConfig['location'], extra: string | Partial<EndpointParamConfig>): EndpointParamConfig => ({
-  location,
-  ...((typeof extra === 'string' ? { name: extra } : extra))
-});
+type ParamDecorator = (instance: ClassInstance, property: string | symbol, idx: number) => void;
 
 /**
  * Define a parameter
  * @param location The location of the parameter
  * @param extra Any extra configuration for the param
- * @augments `@travetto/web:Param`
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
  */
-export function Param(location: EndpointParamConfig['location'], extra: string | Partial<EndpointParamConfig>): ParamDecorator {
-  const param = paramConfig(location, extra);
-  return (target: ClassInstance, propertyKey: string | symbol, idx: number): void => {
-    const handler = target.constructor.prototype[propertyKey];
-    ControllerRegistry.registerEndpointParameter(target.constructor, handler, param, idx);
+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 });
+    }
+
+    ControllerRegistryIndex.getForRegister(getClass(instance)).registerEndpointParameter(property, idx, {
+      index: idx, location, ...config
+    });
   };
 }
 
 /**
  * Define a Path param
  * @param param The param configuration or name
- * @augments `@travetto/web:Param`
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
  */
-export function PathParam(param: string | Partial<EndpointParamConfig> = {}): ParamDecorator { return Param('path', param); }
+export function PathParam(param: string | Partial<EndpointParameterConfig> = {}): ParamDecorator { return Param('path', param); }
 /**
  * Define a Query param
  * @param param The param configuration or name
- * @augments `@travetto/web:Param`
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
  */
-export function QueryParam(param: string | Partial<EndpointParamConfig> = {}): ParamDecorator { return Param('query', param); }
+export function QueryParam(param: string | Partial<EndpointParameterConfig> = {}): ParamDecorator { return Param('query', param); }
 /**
  * Define a Header param
  * @param param The param configuration or name
- * @augments `@travetto/web:Param`
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
  */
-export function HeaderParam(param: string | Partial<EndpointParamConfig> = {}): ParamDecorator { return Param('header', param); }
+export function HeaderParam(param: string | Partial<EndpointParameterConfig> = {}): ParamDecorator { return Param('header', param); }
 /**
  * Define a body param as an input
  * @param param The param configuration
- * @augments `@travetto/web:Param`
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
  */
-export function Body(param: Partial<EndpointParamConfig> = {}): ParamDecorator { return Param('body', param); }
+export function Body(param: Partial<EndpointParameterConfig> = {}): ParamDecorator { return Param('body', param); }
 
 /**
  * A contextual field as provided by the WebAsyncContext
- * @augments `@travetto/web:ContextParam`
+ * @augments `@travetto/schema:Field`
+ * @kind decorator
  */
-export function ContextParam(config?: { target: Class }) {
-  return (inst: unknown, field: string): void =>
-    ControllerRegistry.registerControllerContextParam(asConstructable(inst).constructor, field, config!.target);
+export function ContextParam() {
+  return (instance: ClassInstance, property: string | symbol): void => {
+    ControllerRegistryIndex.getForRegister(getClass(instance)).register({ contextParams: { [property]: true } });
+    ControllerRegistryIndex.bindContextParamsOnPostConstruct(getClass(instance));
+  };
 }

package/src/interceptor/body.ts

@@ -1,4 +1,4 @@
-import { Injectable, Inject, DependencyRegistry } from '@travetto/di';
+import { Injectable, Inject, DependencyRegistryIndex } from '@travetto/di';
 import { Config } from '@travetto/config';
 import { toConcrete } from '@travetto/runtime';
 import { Ignore } from '@travetto/schema';
@@ -66,7 +66,7 @@ export class BodyInterceptor implements WebInterceptor<WebBodyConfig> {
 
   async postConstruct(): Promise<void> {
     // Load all the parser types
-    const instances = await DependencyRegistry.getCandidateInstances(toConcrete<BodyContentParser>());
+    const instances = await DependencyRegistryIndex.getInstances(toConcrete<BodyContentParser>());
     for (const instance of instances) {
       this.parsers[instance.type] = instance;
     }
@@ -96,8 +96,8 @@ export class BodyInterceptor implements WebInterceptor<WebBodyConfig> {
       return next();
     }
 
-    const [baseType,] = contentType.value.split('/');
-    const parserType = config.parsingTypes[contentType.value] ?? config.parsingTypes[baseType];
+    const [baseMimeType,] = contentType.value.split('/');
+    const parserType = config.parsingTypes[contentType.value] ?? config.parsingTypes[baseMimeType];
     if (!parserType) {
       return next();
     }