@travetto/web 6.0.2 → 7.0.0-rc.0

package/src/util/endpoint.ts

@@ -1,6 +1,6 @@
 import { asConstructable, castTo, Class, Runtime, TypedObject } from '@travetto/runtime';
-import { BindUtil, FieldConfig, SchemaRegistry, SchemaValidator, ValidationResultError } from '@travetto/schema';
-import { DependencyRegistry } from '@travetto/di';
+import { BindUtil, SchemaParameterConfig, SchemaRegistryIndex, SchemaValidator, ValidationResultError } from '@travetto/schema';
+import { DependencyRegistryIndex } from '@travetto/di';
 import { RetargettingProxy } from '@travetto/registry';
 
 import { WebChainedFilter, WebChainedContext, WebFilter } from '../types/filter.ts';
@@ -8,8 +8,8 @@ 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, EndpointParamConfig } from '../registry/types.ts';
-import { ControllerRegistry } from '../registry/controller.ts';
+import { EndpointConfig, ControllerConfig, EndpointParameterConfig } from '../registry/types.ts';
+import { ControllerRegistryIndex } from '../registry/registry-index.ts';
 import { WebCommonUtil } from './common.ts';
 
 
@@ -81,27 +81,57 @@ export class EndpointUtil {
     ]);
   }
 
+
   /**
-   * Extract parameter from request
+   * Extract parameter value from request
+   * @param request The request
+   * @param param The parameter config
+   * @param name The parameter name
+   * @param isArray Whether the parameter is an array
    */
-  static extractParameter(request: WebRequest, param: EndpointParamConfig, field: FieldConfig, value?: unknown): unknown {
-    if (value !== undefined && value !== this.MissingParamSymbol) {
-      return value;
-    } else if (param.extract) {
-      return param.extract(request, param);
-    }
-
-    const name = param.name!;
+  static extractParameterValue(request: WebRequest, param: EndpointParameterConfig, name: string, isArray?: boolean): unknown {
     switch (param.location) {
-      case 'path': return request.context.pathParams?.[name];
-      case 'header': return field.array ? request.headers.getList(name) : request.headers.get(name);
       case 'body': return request.body;
+      case 'path': return request.context.pathParams?.[name];
+      case 'header': return isArray ? request.headers.getList(name) : request.headers.get(name);
       case 'query': {
         const withQuery: typeof request & { [WebQueryExpandedSymbol]?: Record<string, unknown> } = request;
         const q = withQuery[WebQueryExpandedSymbol] ??= BindUtil.expandPaths(request.context.httpQuery ?? {});
-        return param.prefix ? q[param.prefix] : (field.type.Ⲑid ? q : q[name]);
+        return q[name];
+      }
+    }
+  }
+
+  /**
+   * Extract parameter from request
+   * @param request The request
+   * @param param The parameter config
+   * @param input The schema parameter config
+   */
+  static extractParameter(request: WebRequest, param: EndpointParameterConfig, input: SchemaParameterConfig): unknown {
+    if (param.extract) {
+      return param.extract(request, param);
+    } else if (param.location === 'query') {
+      // TODO: Revisit this logic?
+      const withQuery: typeof request & { [WebQueryExpandedSymbol]?: Record<string, unknown> } = request;
+      const q = withQuery[WebQueryExpandedSymbol] ??= BindUtil.expandPaths(request.context.httpQuery ?? {});
+      if (param.prefix) { // Has a prefix provided
+        return q[param.prefix];
+      } else if (input.type.Ⲑid) { // Is a full type
+        return q;
       }
     }
+
+    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;
+        }
+      }
+    }
+    return res;
   }
 
   /**
@@ -112,22 +142,27 @@ export class EndpointUtil {
    */
   static async extractParameters(endpoint: EndpointConfig, request: WebRequest): Promise<unknown[]> {
     const cls = endpoint.class;
-    const method = endpoint.name;
     const vals = WebCommonUtil.getRequestParams(request);
+    const { parameters } = SchemaRegistryIndex.getMethodConfig(cls, endpoint.methodName);
+    const combined = parameters.map((cfg) =>
+      ({ schema: cfg, param: endpoint.parameters[cfg.index], value: vals?.[cfg.index] }));
 
     try {
-      const fields = SchemaRegistry.getMethodSchema(cls, method);
-      const extracted = endpoint.params.map((c, i) => this.extractParameter(request, c, fields[i], vals?.[i]));
-      const params = BindUtil.coerceMethodParams(cls, method, extracted);
-      await SchemaValidator.validateMethod(cls, method, params, endpoint.params.map(x => x.prefix));
+      const extracted = combined.map(({ param, schema, value }) =>
+        (value !== undefined && value !== this.MissingParamSymbol) ?
+          value :
+          this.extractParameter(request, param, schema)
+      );
+      const params = BindUtil.coerceMethodParams(cls, endpoint.methodName, extracted);
+      await SchemaValidator.validateMethod(cls, endpoint.methodName, params, endpoint.parameters.map(x => x.prefix));
       return params;
     } catch (err) {
       if (err instanceof ValidationResultError) {
         for (const el of err.details?.errors ?? []) {
           if (el.kind === 'required') {
-            const config = endpoint.params.find(x => x.name === el.path);
+            const config = combined.find(x => x.schema.name === el.path);
             if (config) {
-              el.message = `Missing ${config.location.replace(/s$/, '')}: ${config.name}`;
+              el.message = `Missing ${config.param.location} value: ${config.schema.name}`;
             }
           }
         }
@@ -184,7 +219,7 @@ export class EndpointUtil {
     const endpointFilters = [
       ...(controller?.filters ?? []).map(fn => fn.bind(controller?.instance)),
       ...(endpoint.filters ?? []).map(fn => fn.bind(endpoint.instance)),
-      ...(endpoint.params.filter(cfg => cfg.resolve).map(fn => fn.resolve!))
+      ...(endpoint.parameters.filter(cfg => cfg.resolve).map(fn => fn.resolve!))
     ]
       .map(fn => ({ filter: fn }));
 
@@ -202,14 +237,14 @@ export class EndpointUtil {
    * Get bound endpoints, honoring the conditional status
    */
   static async getBoundEndpoints(c: Class): Promise<EndpointConfig[]> {
-    const config = ControllerRegistry.get(c);
+    const config = ControllerRegistryIndex.getConfig(c);
 
     // Skip registering conditional controllers
     if (config.conditional && !await config.conditional()) {
       return [];
     }
 
-    config.instance = await DependencyRegistry.getInstance(config.class);
+    config.instance = await DependencyRegistryIndex.getInstance(config.class);
 
     if (Runtime.dynamic) {
       config.instance = RetargettingProxy.unwrap(config.instance);

package/src/util/net.ts

@@ -58,4 +58,18 @@ export class NetUtil {
 
     return useIPv4 ? '0.0.0.0' : '::';
   }
+
+  /**
+   * Free a port if it is in use, typically used to resolve port conflicts.
+   * @param err The error that may indicate a port conflict
+   * @returns Returns true if the port was freed, false if not handled
+   */
+  static async freePortOnConflict(err: unknown): Promise<boolean> {
+    if (NetUtil.isPortUsedError(err) && typeof err.port === 'number') {
+      await NetUtil.freePort(err.port);
+      return true;
+    } else {
+      return false;
+    }
+  }
 }

package/support/test/dispatch-util.ts

@@ -64,30 +64,11 @@ export class WebTestDispatchUtil {
     return response;
   }
 
-  static async toFetchRequestInit(request: WebRequest): Promise<{ init: RequestInit, path: string }> {
-    const { context: { httpQuery: query, httpMethod: method, path }, headers } = request;
-
-    let q = '';
-    if (query && Object.keys(query).length) {
-      const pairs = Object.fromEntries(Object.entries(query).map(([k, v]) => [k, v === null || v === undefined ? '' : `${v}`] as const));
-      q = `?${new URLSearchParams(pairs).toString()}`;
+  static buildPath(request: WebRequest): string {
+    const params = new URLSearchParams();
+    for (const [k, v] of Object.entries(request.context.httpQuery ?? {})) {
+      params.set(k, v === null || v === undefined ? '' : `${v}`);
     }
-
-    const finalPath = `${path}${q}`;
-
-    const body: RequestInit['body'] =
-      WebBodyUtil.isRaw(request.body) ?
-        await toBuffer(request.body) :
-        castTo(request.body);
-
-    return { path: finalPath, init: { headers, method, body } };
-  }
-
-  static async fromFetchResponse(response: Response): Promise<WebResponse> {
-    return new WebResponse({
-      body: Buffer.from(await response.arrayBuffer()),
-      context: { httpStatusCode: response.status },
-      headers: response.headers
-    });
+    return [request.context.path, params.toString()].join('?').replace(/[?]$/, '');
   }
 }

package/support/test/suite/base.ts

@@ -1,8 +1,9 @@
-import { RootRegistry } from '@travetto/registry';
+import { Registry } from '@travetto/registry';
 import { castTo, Class } from '@travetto/runtime';
 import { AfterAll, BeforeAll } from '@travetto/test';
-import { DependencyRegistry, Injectable } from '@travetto/di';
+import { DependencyRegistryIndex, Injectable } from '@travetto/di';
 import { ConfigSource, ConfigSpec } from '@travetto/config';
+import { Schema } from '@travetto/schema';
 
 import { WebDispatcher } from '../../../src/types/dispatch.ts';
 import { WebRequest, WebRequestContext } from '../../../src/types/request.ts';
@@ -18,7 +19,7 @@ export class WebTestConfig implements ConfigSource {
           cookie: { secure: false },
           trustProxy: { ips: ['*'] },
           http: {
-            ssl: { active: false },
+            tls: false,
             port: -1,
           },
           etag: {
@@ -35,6 +36,7 @@ export class WebTestConfig implements ConfigSource {
 /**
  * Base Web Suite
  */
+@Schema()
 export abstract class BaseWebSuite {
 
   #cleanup?: () => void;
@@ -45,9 +47,9 @@ export abstract class BaseWebSuite {
 
   @BeforeAll()
   async initServer(): Promise<void> {
-    await RootRegistry.init();
+    await Registry.init();
     this.#cleanup = await this.serve?.();
-    this.#dispatcher = await DependencyRegistry.getInstance(this.dispatcherType);
+    this.#dispatcher = await DependencyRegistryIndex.getInstance(this.dispatcherType);
   }
 
   @AfterAll()

package/support/test/suite/schema.ts

@@ -1,8 +1,8 @@
 import assert from 'node:assert';
 
 import { Suite, Test } from '@travetto/test';
-import { Schema, SchemaRegistry, ValidationResultError, Validator } from '@travetto/schema';
-import { Controller, Post, Get, ControllerRegistry, WebResponse, PathParam, QueryParam, HttpMethod } from '@travetto/web';
+import { Schema, SchemaRegistryIndex, ValidationResultError, Validator } from '@travetto/schema';
+import { Controller, Post, Get, ControllerRegistryIndex, WebResponse, PathParam, QueryParam, HttpMethod } from '@travetto/web';
 
 import { BaseWebSuite } from './base.ts';
 
@@ -104,10 +104,16 @@ class SchemaAPI {
 }
 
 function getEndpoint(path: string, method: HttpMethod) {
-  return ControllerRegistry.get(SchemaAPI)
+  return ControllerRegistryIndex.getConfig(SchemaAPI)
     .endpoints.find(x => x.path === path && x.httpMethod === method)!;
 }
 
+function getEndpointResponse(path: string, method: HttpMethod) {
+  const ep = getEndpoint(path, method);
+  const resp = SchemaRegistryIndex.getMethodConfig(SchemaAPI, ep.methodName);
+  return resp?.returnType?.type;
+}
+
 @Suite()
 export abstract class SchemaWebServerSuite extends BaseWebSuite {
 
@@ -226,50 +232,50 @@ export abstract class SchemaWebServerSuite extends BaseWebSuite {
 
   @Test()
   async verifyVoid() {
-    const ep = getEndpoint('/void', 'GET');
-    assert(ep.responseType === undefined);
+    const responseType = getEndpointResponse('/void', 'GET');
+    assert(responseType === undefined);
   }
 
   @Test()
   async verifyVoidAll() {
-    const ep = getEndpoint('/voidAll', 'GET');
-    assert(ep.responseType === undefined);
+    const responseType = getEndpointResponse('/voidAll', 'GET');
+    assert(responseType === undefined);
   }
 
   @Test()
   async verifyList() {
-    const ep = getEndpoint('/users', 'GET');
-    assert(ep.responseType?.type === User);
+    const responseType = getEndpointResponse('/users', 'GET');
+    assert(responseType === User);
   }
 
   @Test()
   async verifyShapeAll() {
-    const ep = getEndpoint('/allShapes', 'GET');
-    console.log(`${ep.responseType}`);
+    const responseType = getEndpointResponse('/allShapes', 'GET');
+    console.log(`${responseType}`);
   }
 
   @Test()
   async verifyShapeClass() {
-    const ep = getEndpoint('/classShape/:shape', 'GET');
-    assert(ep.responseType);
-    assert(SchemaRegistry.has(ep.responseType!.type));
+    const responseType = getEndpointResponse('/classShape/:shape', 'GET');
+    assert(responseType);
+    assert(SchemaRegistryIndex.has(responseType));
   }
 
   @Test()
   async verifyRenderable() {
-    const ep = getEndpoint('/renderable/:age', 'GET');
-    assert(ep.responseType?.type === undefined);
+    const responseType = getEndpointResponse('/renderable/:age', 'GET');
+    assert(responseType === undefined);
   }
 
   @Test()
   async verifyCustomSerializeable() {
-    const ep = getEndpoint('/customSerialize', 'GET');
-    assert(ep.responseType?.type === User);
+    const responseType = getEndpointResponse('/customSerialize', 'GET');
+    assert(responseType === User);
   }
 
   @Test()
   async verifyCustomSerializeable2() {
-    const ep = getEndpoint('/customSerialize2', 'GET');
-    assert(ep.responseType?.type === User);
+    const responseType = getEndpointResponse('/customSerialize2', 'GET');
+    assert(responseType === User);
   }
 }

package/support/test/suite/standard.ts

@@ -1,18 +1,17 @@
 import assert from 'node:assert';
 
 import { Test, Suite, BeforeAll } from '@travetto/test';
+import { Registry } from '@travetto/registry';
 
 import { BaseWebSuite } from './base.ts';
 import { TestController } from './controller.ts';
-import { ControllerRegistry } from '../../../src/registry/controller.ts';
 
 @Suite()
 export abstract class StandardWebServerSuite extends BaseWebSuite {
 
   @BeforeAll()
   async init() {
-    ControllerRegistry.register(TestController);
-    await ControllerRegistry.install(TestController, { type: 'added' });
+    Registry.process([{ type: 'added', curr: TestController }]);
   }
 
   @Test()

package/src/registry/controller.ts

@@ -1,292 +0,0 @@
-import { DependencyRegistry } from '@travetto/di';
-import { type Primitive, type Class, asFull, castTo, asConstructable, ClassInstance } from '@travetto/runtime';
-import { MetadataRegistry } from '@travetto/registry';
-
-import { EndpointConfig, ControllerConfig, EndpointDecorator, EndpointParamConfig, EndpointFunctionDescriptor, EndpointFunction } from './types.ts';
-import { WebChainedFilter, WebFilter } from '../types/filter.ts';
-import { WebInterceptor } from '../types/interceptor.ts';
-import { WebHeaders } from '../types/headers.ts';
-
-import { WebAsyncContext } from '../context.ts';
-
-type ValidFieldNames<T> = {
-  [K in keyof T]:
-  (T[K] extends (Primitive | undefined) ? K :
-    (T[K] extends (Function | undefined) ? never :
-      K))
-}[keyof T];
-
-type RetainFields<T> = Pick<T, ValidFieldNames<T>>;
-
-/**
- * Controller registry
- */
-class $ControllerRegistry extends MetadataRegistry<ControllerConfig, EndpointConfig> {
-
-  #endpointsById = new Map<string, EndpointConfig>();
-
-  constructor() {
-    super(DependencyRegistry);
-  }
-
-  async #bindContextParams<T>(inst: ClassInstance<T>): Promise<void> {
-    const ctx = await DependencyRegistry.getInstance(WebAsyncContext);
-    const map = this.get(inst.constructor).contextParams;
-    for (const [field, type] of Object.entries(map)) {
-      Object.defineProperty(inst, field, { get: ctx.getSource(type) });
-    }
-  }
-
-  getEndpointById(id: string): EndpointConfig | undefined {
-    return this.#endpointsById.get(id.replace(':', '#'));
-  }
-
-  createPending(cls: Class): ControllerConfig {
-    return {
-      class: cls,
-      filters: [],
-      interceptorConfigs: [],
-      basePath: '',
-      externalName: cls.name.replace(/(Controller|Web|Service)$/, ''),
-      endpoints: [],
-      contextParams: {},
-      responseHeaders: {}
-    };
-  }
-
-  createPendingField(cls: Class, endpoint: EndpointFunction): EndpointConfig {
-    const controllerConf = this.getOrCreatePending(cls);
-
-    const fieldConf: EndpointConfig = {
-      id: `${cls.name}#${endpoint.name}`,
-      path: '/',
-      fullPath: '/',
-      cacheable: false,
-      allowsBody: false,
-      class: cls,
-      filters: [],
-      params: [],
-      interceptorConfigs: [],
-      name: endpoint.name,
-      endpoint,
-      responseHeaders: {},
-      finalizedResponseHeaders: new WebHeaders(),
-      responseFinalizer: undefined
-    };
-
-    controllerConf.endpoints!.push(fieldConf);
-
-    return fieldConf;
-  }
-
-  /**
-   * Register the endpoint config
-   * @param cls Controller class
-   * @param endpoint Endpoint target function
-   */
-  getOrCreateEndpointConfig<T>(cls: Class<T>, endpoint: EndpointFunction): EndpointConfig {
-    const fieldConf = this.getOrCreatePendingField(cls, endpoint);
-    return asFull(fieldConf);
-  }
-
-  /**
-   * Register the controller filter
-   * @param cls Controller class
-   * @param filter The filter to call
-   */
-  registerControllerFilter(target: Class, filter: WebFilter | WebChainedFilter): void {
-    const config = this.getOrCreatePending(target);
-    config.filters!.push(filter);
-  }
-
-  /**
-   * Register the controller filter
-   * @param cls Controller class
-   * @param endpoint Endpoint function
-   * @param filter The filter to call
-   */
-  registerEndpointFilter(target: Class, endpoint: EndpointFunction, filter: WebFilter | WebChainedFilter): void {
-    const config = this.getOrCreateEndpointConfig(target, endpoint);
-    config.filters!.unshift(filter);
-  }
-
-  /**
-   * Register the endpoint parameter
-   * @param cls Controller class
-   * @param endpoint Endpoint function
-   * @param param The param config
-   * @param index The parameter index
-   */
-  registerEndpointParameter(target: Class, endpoint: EndpointFunction, param: EndpointParamConfig, index: number): void {
-    const config = this.getOrCreateEndpointConfig(target, endpoint);
-    if (index >= config.params.length) {
-      config.params.length = index + 1;
-    }
-    config.params[index] = param;
-  }
-
-  /**
-   * Register the endpoint interceptor config
-   * @param cls Controller class
-   * @param endpoint Endpoint function
-   * @param param The param config
-   * @param index The parameter index
-   */
-  registerEndpointInterceptorConfig<T extends WebInterceptor>(target: Class, endpoint: EndpointFunction, interceptorCls: Class<T>, config: Partial<T['config']>): void {
-    const endpointConfig = this.getOrCreateEndpointConfig(target, endpoint);
-    (endpointConfig.interceptorConfigs ??= []).push([interceptorCls, { ...config }]);
-  }
-
-  /**
-   * Register the controller interceptor config
-   * @param cls Controller class
-   * @param param The param config
-   * @param index The parameter index
-   */
-  registerControllerInterceptorConfig<T extends WebInterceptor>(target: Class, interceptorCls: Class<T>, config: Partial<T['config']>): void {
-    const controllerConfig = this.getOrCreatePending(target);
-    (controllerConfig.interceptorConfigs ??= []).push([interceptorCls, { ...config }]);
-  }
-
-  /**
-   * Register a controller context param
-   * @param target Controller class
-   * @param field Field on controller to bind context param to
-   * @param type The context type to bind to field
-   */
-  registerControllerContextParam<T>(target: Class, field: string, type: Class<T>): void {
-    const controllerConfig = this.getOrCreatePending(target);
-    controllerConfig.contextParams![field] = type;
-    DependencyRegistry.registerPostConstructHandler(target, 'ContextParam', inst => this.#bindContextParams(inst));
-  }
-
-  /**
-   * Create a filter decorator
-   * @param filter The filter to call
-   */
-  createFilterDecorator(filter: WebFilter): EndpointDecorator {
-    return (target: unknown, prop?: symbol | string, descriptor?: EndpointFunctionDescriptor): void => {
-      if (prop) {
-        this.registerEndpointFilter(asConstructable(target).constructor, descriptor!.value!, filter);
-      } else {
-        this.registerControllerFilter(castTo(target), filter);
-      }
-    };
-  }
-
-  /**
-   * Register a controller/endpoint with specific config for an interceptor
-   * @param cls The interceptor to register data for
-   * @param cfg The partial config override
-   */
-  createInterceptorConfigDecorator<T extends WebInterceptor>(
-    cls: Class<T>,
-    cfg: Partial<RetainFields<T['config']>>,
-    extra?: Partial<EndpointConfig & ControllerConfig>
-  ): EndpointDecorator {
-    return (target: unknown, prop?: symbol | string, descriptor?: EndpointFunctionDescriptor): void => {
-      const outCls: Class = descriptor ? asConstructable(target).constructor : castTo(target);
-      if (prop && descriptor) {
-        this.registerEndpointInterceptorConfig(outCls, descriptor!.value!, cls, castTo(cfg));
-        extra && this.registerPendingEndpoint(outCls, descriptor, extra);
-      } else {
-        this.registerControllerInterceptorConfig(outCls, cls, castTo(cfg));
-        extra && this.registerPending(outCls, extra);
-      }
-    };
-  }
-
-  /**
-   * Merge describable
-   * @param src Root describable (controller, endpoint)
-   * @param dest Target (controller, endpoint)
-   */
-  mergeCommon(src: Partial<ControllerConfig | EndpointConfig>, dest: Partial<ControllerConfig | EndpointConfig>): void {
-    dest.filters = [...(dest.filters ?? []), ...(src.filters ?? [])];
-    dest.interceptorConfigs = [...(dest.interceptorConfigs ?? []), ...(src.interceptorConfigs ?? [])];
-    dest.interceptorExclude = dest.interceptorExclude ?? src.interceptorExclude;
-    dest.title = src.title || dest.title;
-    dest.description = src.description || dest.description;
-    dest.documented = src.documented ?? dest.documented;
-    dest.responseHeaders = { ...src.responseHeaders, ...dest.responseHeaders };
-    dest.responseContext = { ...src.responseContext, ...dest.responseContext };
-  }
-
-  /**
-   * Register an endpoint as pending
-   * @param target Controller class
-   * @param descriptor Prop descriptor
-   * @param config The endpoint config
-   */
-  registerPendingEndpoint(target: Class, descriptor: EndpointFunctionDescriptor, config: Partial<EndpointConfig>): EndpointFunctionDescriptor {
-    const srcConf = this.getOrCreateEndpointConfig(target, descriptor.value!);
-    srcConf.cacheable = config.cacheable ?? srcConf.cacheable;
-    srcConf.httpMethod = config.httpMethod ?? srcConf.httpMethod;
-    srcConf.allowsBody = config.allowsBody ?? srcConf.allowsBody;
-    srcConf.path = config.path || srcConf.path;
-    srcConf.responseType = config.responseType ?? srcConf.responseType;
-    srcConf.requestType = config.requestType ?? srcConf.requestType;
-    srcConf.params = (config.params ?? srcConf.params).map(x => ({ ...x }));
-    srcConf.responseFinalizer = config.responseFinalizer ?? srcConf.responseFinalizer;
-
-    // Ensure path starts with '/'
-    if (!srcConf.path.startsWith('/')) {
-      srcConf.path = `/${srcConf.path}`;
-    }
-
-    this.mergeCommon(config, srcConf);
-
-    return descriptor;
-  }
-
-  /**
-   * Register a pending configuration
-   * @param target The target class
-   * @param config The controller configuration
-   */
-  registerPending(target: Class, config: Partial<ControllerConfig>): void {
-    const srcConf = this.getOrCreatePending(target);
-    srcConf.basePath = config.basePath || srcConf.basePath;
-
-    if (!srcConf.basePath!.startsWith('/')) {
-      srcConf.basePath = `/${srcConf.basePath}`;
-    }
-
-    srcConf.contextParams = { ...srcConf.contextParams, ...config.contextParams };
-
-
-    this.mergeCommon(config, srcConf);
-  }
-
-  /**
-   * Finalize endpoints, removing duplicates based on ids
-   */
-  onInstallFinalize(cls: Class): ControllerConfig {
-    const final = asFull(this.getOrCreatePending(cls));
-
-    // Store for lookup
-    for (const ep of final.endpoints) {
-      this.#endpointsById.set(ep.id, ep);
-      // Store full path from base for use in other contexts
-      ep.fullPath = `/${final.basePath}/${ep.path}`.replace(/[/]{1,4}/g, '/').replace(/(.)[/]$/, (_, a) => a);
-      ep.finalizedResponseHeaders = new WebHeaders({ ...final.responseHeaders, ...ep.responseHeaders });
-      ep.responseContext = { ...final.responseContext, ...ep.responseContext };
-    }
-
-    if (this.has(final.basePath)) {
-      console.debug('Reloading controller', { name: cls.name, path: final.basePath });
-    }
-
-    return final;
-  }
-
-  onUninstallFinalize<T>(cls: Class<T>): void {
-    const toDelete = [...this.#endpointsById.values()].filter(x => x.class.name === cls.name);
-    for (const k of toDelete) {
-      this.#endpointsById.delete(k.id);
-    }
-    super.onUninstallFinalize(cls);
-  }
-}
-
-export const ControllerRegistry = new $ControllerRegistry();