refactor: Remove HttpHandlerContext interface

joachimvh · joachimvh · commit bd6bcb05dba9 · 2025-02-26T10:44:22.000+01:00
diff --git a/packages/uma/src/index.ts b/packages/uma/src/index.ts
@@ -60,7 +60,6 @@ export * from './util/ReType';
 // HTTP
 export * from './util/http/identifier/BaseTargetExtractor';
 export * from './util/http/models/HttpHandler';
-export * from './util/http/models/HttpHandlerContext';
 export * from './util/http/models/HttpHandlerRequest';
 export * from './util/http/models/HttpHandlerResponse';
 export * from './util/http/server/ErrorHandler';
diff --git a/packages/uma/src/routes/Config.ts b/packages/uma/src/routes/Config.ts
@@ -2,7 +2,7 @@ import { ASYMMETRIC_CRYPTOGRAPHIC_ALGORITHM }
   from '@solid/access-token-verifier/dist/constant/ASYMMETRIC_CRYPTOGRAPHIC_ALGORITHM';
 import { getLoggerFor } from '@solid/community-server';
 import { HttpHandler } from '../util/http/models/HttpHandler';
-import { HttpHandlerContext } from '../util/http/models/HttpHandlerContext';
+import { HttpHandlerRequest } from '../util/http/models/HttpHandlerRequest';
 import { HttpHandlerResponse } from '../util/http/models/HttpHandlerResponse';
 
 // eslint-disable no-unused-vars
@@ -49,11 +49,11 @@ export class ConfigRequestHandler extends HttpHandler {
   /**
    * Returns the endpoint's UMA configuration
    *
-   * @param {HttpHandlerContext} context - an irrelevant incoming context
-   * @return {Observable<HttpHandlerResponse>} - the mock response
+   * @param {HttpHandlerRequest} request - an irrelevant incoming context
+   * @return {HttpHandlerResponse} - the mock response
    */
-  async handle(context: HttpHandlerContext): Promise<HttpHandlerResponse> {
-    this.logger.info(`Received discovery request at '${context.request.url}'`);
+  async handle(request: HttpHandlerRequest): Promise<HttpHandlerResponse> {
+    this.logger.info(`Received discovery request at '${request.url}'`);
 
     return {
       body: JSON.stringify(this.getConfig()),
diff --git a/packages/uma/src/routes/Introspection.ts b/packages/uma/src/routes/Introspection.ts
@@ -1,5 +1,5 @@
-import { HttpHandlerContext } from '../util/http/models/HttpHandlerContext';
 import { HttpHandler } from '../util/http/models/HttpHandler';
+import { HttpHandlerRequest } from '../util/http/models/HttpHandlerRequest';
 import { HttpHandlerResponse } from '../util/http/models/HttpHandlerResponse';
 import { AccessToken } from '../tokens/AccessToken';
 import { JwtTokenFactory } from '../tokens/JwtTokenFactory';
@@ -28,17 +28,16 @@ export class IntrospectionHandler extends HttpHandler {
   constructor(
     private readonly tokenStore: KeyValueStorage<string, AccessToken>,
     private readonly jwtTokenFactory: JwtTokenFactory,
-    private readonly keyGen: JwkGenerator,
   ) {
     super();
   }
 
   /**
   * Handle incoming requests for token introspection
-  * @param {HttpHandlerContext} param0
-  * @return {Observable<HttpHandlerResponse<any>>}
+  * @param {HttpHandlerRequest} request
+  * @return {HttpHandlerResponse}
   */
-  async handle({request}: HttpHandlerContext): Promise<HttpHandlerResponse<any>> {
+  async handle(request: HttpHandlerRequest): Promise<HttpHandlerResponse<any>> {
     if (!await verifyRequest(request)) throw new UnauthorizedHttpError();
 
     if (request.headers['content-type'] !== 'application/x-www-form-urlencoded') {
diff --git a/packages/uma/src/routes/Jwks.ts b/packages/uma/src/routes/Jwks.ts
@@ -1,5 +1,5 @@
 import { HttpHandler } from '../util/http/models/HttpHandler';
-import { HttpHandlerContext } from '../util/http/models/HttpHandlerContext';
+import { HttpHandlerRequest } from '../util/http/models/HttpHandlerRequest';
 import { HttpHandlerResponse } from '../util/http/models/HttpHandlerResponse';
 import { getLoggerFor, JwkGenerator } from '@solid/community-server';
 
@@ -22,11 +22,11 @@ export class JwksRequestHandler extends HttpHandler {
 
   /**
      * Returns the JSON Web KeySet for specified keyholder
-     * @param {HttpHandlerContext} context - an irrelevant incoming context
-     * @return {Observable<HttpHandlerResponse>} - the JWKS response
+     * @param {HttpHandlerRequest} request
+     * @return {HttpHandlerResponse} - the JWKS response
      */
-  async handle(context: HttpHandlerContext): Promise<HttpHandlerResponse> {
-    this.logger.info(`Received JWKS request at '${context.request.url}'`);
+  async handle(request: HttpHandlerRequest): Promise<HttpHandlerResponse> {
+    this.logger.info(`Received JWKS request at '${request.url}'`);
 
     const key = await this.generator.getPublicKey();
 
diff --git a/packages/uma/src/routes/ResourceRegistration.ts b/packages/uma/src/routes/ResourceRegistration.ts
@@ -8,7 +8,6 @@ import {
   UnsupportedMediaTypeHttpError
 } from '@solid/community-server';
 import {HttpHandler} from '../util/http/models/HttpHandler';
-import {HttpHandlerContext} from '../util/http/models/HttpHandlerContext';
 import {HttpHandlerResponse} from '../util/http/models/HttpHandlerResponse';
 import {v4} from 'uuid';
 import { HttpHandlerRequest } from '../util/http/models/HttpHandlerRequest';
@@ -38,10 +37,10 @@ export class ResourceRegistrationRequestHandler extends HttpHandler {
 
   /**
   * Handle incoming requests for resource registration
-  * @param {HttpHandlerContext} param0
-  * @return {Observable<HttpHandlerResponse<PermissionRegistrationResponse>>}
+  * @param {HttpHandlerRequest} request
+  * @return {HttpHandlerResponse}
   */
-  async handle({ request }: HttpHandlerContext): Promise<HttpHandlerResponse<any>> {
+  async handle(request: HttpHandlerRequest): Promise<HttpHandlerResponse> {
     const signer = await extractRequestSigner(request);
 
     // TODO: check if signer is actually the correct one
diff --git a/packages/uma/src/routes/Ticket.ts b/packages/uma/src/routes/Ticket.ts
@@ -5,7 +5,7 @@ import {
   UnsupportedMediaTypeHttpError
 } from '@solid/community-server';
 import { HttpHandler } from '../util/http/models/HttpHandler';
-import { HttpHandlerContext } from '../util/http/models/HttpHandlerContext';
+import { HttpHandlerRequest } from '../util/http/models/HttpHandlerRequest';
 import { HttpHandlerResponse } from '../util/http/models/HttpHandlerResponse';
 import { array, reType } from '../util/ReType';
 import { Permission } from '../views/Permission';
@@ -39,10 +39,10 @@ export class TicketRequestHandler extends HttpHandler {
 
   /**
   * Handle incoming requests for permission registration
-  * @param {HttpHandlerContext} param0
-  * @return {Observable<HttpHandlerResponse<PermissionRegistrationResponse>>}
+  * @param {HttpHandlerRequest} request
+  * @return {HttpHandlerResponse}
   */
-  async handle({request}: HttpHandlerContext): Promise<HttpHandlerResponse<any>> {
+  async handle(request: HttpHandlerRequest): Promise<HttpHandlerResponse> {
     this.logger.info(`Received permission registration request.`);
     if (!await verifyRequest(request)) throw new UnauthorizedHttpError();
 
diff --git a/packages/uma/src/routes/Token.ts b/packages/uma/src/routes/Token.ts
@@ -5,7 +5,7 @@ import {
   UnsupportedMediaTypeHttpError
 } from '@solid/community-server';
 import { HttpHandler } from '../util/http/models/HttpHandler';
-import { HttpHandlerContext } from '../util/http/models/HttpHandlerContext';
+import { HttpHandlerRequest } from '../util/http/models/HttpHandlerRequest';
 import { HttpHandlerResponse } from '../util/http/models/HttpHandlerResponse';
 import { Negotiator } from '../dialog/Negotiator';
 import { DialogInput } from '../dialog/Input';
@@ -27,18 +27,18 @@ export class TokenRequestHandler extends HttpHandler {
   /**
    * Handles an incoming token request.
    *
-   * @param {HttpHandlerContext} input - Request context
-   * @return {Observable<HttpHandlerResponse<any>>} - response
+   * @param {HttpHandlerRequest} request - Request context
+   * @return {HttpHandlerResponse} - response
    */
-  async handle(input: HttpHandlerContext): Promise<HttpHandlerResponse<any>> {
+  async handle(request: HttpHandlerRequest): Promise<HttpHandlerResponse> {
     this.logger.info(`Received token request.`);
 
     // This deviates from UMA, which reads application/x-www-form-urlencoded
-    if (input.request.headers['content-type'] !== 'application/json') {
+    if (request.headers['content-type'] !== 'application/json') {
       throw new UnsupportedMediaTypeHttpError();
     }
 
-    const params = input.request.body;
+    const params = request.body;
 
     // if (params['grant_type'] !== 'urn:ietf:params:oauth:grant-type:uma-ticket') {
     //   throw new BadRequestHttpError(
diff --git a/packages/uma/src/util/http/models/HttpHandler.ts b/packages/uma/src/util/http/models/HttpHandler.ts
@@ -1,7 +1,5 @@
 import { AsyncHandler } from '@solid/community-server';
+import { HttpHandlerRequest } from './HttpHandlerRequest';
 import { HttpHandlerResponse } from './HttpHandlerResponse';
-import { HttpHandlerContext } from './HttpHandlerContext';
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export abstract class HttpHandler<C extends HttpHandlerContext = HttpHandlerContext>
-  extends AsyncHandler<C, HttpHandlerResponse> { }
+export abstract class HttpHandler extends AsyncHandler<HttpHandlerRequest, HttpHandlerResponse> { }
diff --git a/packages/uma/src/util/http/models/HttpHandlerContext.ts b/packages/uma/src/util/http/models/HttpHandlerContext.ts
diff --git a/packages/uma/src/util/http/server/ErrorHandler.ts b/packages/uma/src/util/http/server/ErrorHandler.ts
@@ -1,6 +1,6 @@
 import { getLoggerFor } from '@solid/community-server';
 import {HttpHandler} from '../models/HttpHandler';
-import {HttpHandlerContext} from '../models/HttpHandlerContext';
+import { HttpHandlerRequest } from '../models/HttpHandlerRequest';
 import {HttpHandlerResponse} from '../models/HttpHandlerResponse';
 
 export const statusCodes: { [code: number]: string } = {
@@ -64,14 +64,14 @@ export class JsonHttpErrorHandler extends HttpHandler {
   /**
    * Handle Http Request and catch any Errors that occur
    *
-   * @param {HttpHandlerContext} context - Request context
-   * @return {Observable<HttpHandlerResponse>}
+   * @param {HttpHandlerRequest} request - Request
+   * @return {HttpHandlerResponse}
    */
-  async handle(context: HttpHandlerContext): Promise<HttpHandlerResponse> {
+  async handle(request: HttpHandlerRequest): Promise<HttpHandlerResponse> {
     try {
-      return await this.nestedHandler.handle(context);
+      return await this.nestedHandler.handle(request);
     } catch (error) {
-      this.logger.error(`Returned error for ${context.request.method} '${context.request.url}':` +
+      this.logger.error(`Returned error for ${request.method} '${request.url}':` +
       ` ${(error as Error).name} ${(error as Error).message}`);
 
       return {
diff --git a/packages/uma/src/util/http/server/InteractionRouterHandler.ts b/packages/uma/src/util/http/server/InteractionRouterHandler.ts
@@ -5,7 +5,7 @@ import {
   NotFoundHttpError
 } from '@solid/community-server';
 import { HttpHandler } from '../models/HttpHandler';
-import { HttpHandlerContext } from '../models/HttpHandlerContext';
+import { HttpHandlerRequest } from '../models/HttpHandlerRequest';
 import { HttpHandlerResponse } from '../models/HttpHandlerResponse';
 
 export interface InteractionRouterHandlerArgs {
@@ -34,7 +34,7 @@ export class InteractionRouterHandler extends HttpHandler {
   protected readonly allowedMethods?: string[];
   protected readonly allowedRoutes: InteractionRoute[];
 
-  protected readonly cache = new WeakMap<HttpHandlerContext, HttpHandlerContext>;
+  protected readonly cache = new WeakMap<HttpHandlerRequest, HttpHandlerRequest>;
 
   public constructor(args: InteractionRouterHandlerArgs) {
     super();
@@ -47,14 +47,14 @@ export class InteractionRouterHandler extends HttpHandler {
     }];
   }
 
-  public async canHandle(input: HttpHandlerContext): Promise<void> {
-    if (this.allowedMethods && !this.allowedMethods.includes(input.request.method)) {
-      throw new MethodNotAllowedHttpError([input.request.method]);
+  public async canHandle(request: HttpHandlerRequest): Promise<void> {
+    if (this.allowedMethods && !this.allowedMethods.includes(request.method)) {
+      throw new MethodNotAllowedHttpError([request.method]);
     }
 
     let match: Record<string, string> | undefined;
     for (const route of this.allowedRoutes) {
-      match = route.matchPath(input.request.url.toString());
+      match = route.matchPath(request.url.toString());
       if (match) {
         break;
       }
@@ -64,23 +64,20 @@ export class InteractionRouterHandler extends HttpHandler {
     }
 
 
-    const newInput: HttpHandlerContext = {
-      ...input,
-      request: {
-        ...input.request,
-        parameters: {
-          ...input.request.parameters,
-          ...match,
-        }
+    const newInput: HttpHandlerRequest = {
+      ...request,
+      parameters: {
+        ...request.parameters,
+        ...match,
       }
     }
     await this.handler.canHandle(newInput);
 
-    this.cache.set(input, newInput);
+    this.cache.set(request, newInput);
   }
 
-  public async handle(input: HttpHandlerContext): Promise<HttpHandlerResponse> {
-    const newInput = this.cache.get(input);
+  public async handle(request: HttpHandlerRequest): Promise<HttpHandlerResponse> {
+    const newInput = this.cache.get(request);
     if (!newInput) {
       throw new InternalServerError('Calling handle before a successful canHandle Call');
     }
diff --git a/packages/uma/src/util/http/server/NodeHttpRequestResponseHandler.ts b/packages/uma/src/util/http/server/NodeHttpRequestResponseHandler.ts
@@ -9,7 +9,6 @@ import {
   readableToString,
   TargetExtractor
 } from '@solid/community-server';
-import { HttpHandlerContext } from '../models/HttpHandlerContext';
 import { HttpHandlerRequest } from '../models/HttpHandlerRequest';
 import { HttpHandlerResponse } from '../models/HttpHandlerResponse';
 import { statusCodes } from './ErrorHandler';
@@ -96,11 +95,9 @@ export class NodeHttpRequestResponseHandler extends NodeHttpStreamsHandler {
       body: await this.parseBody(requestStream),
     };
 
-    const context: HttpHandlerContext = { request: httpHandlerRequest };
+    this.logger.info(`Domestic request: ${JSON.stringify({ eventType: 'domestic_request', httpHandlerRequest })}`);
 
-    this.logger.info(`Domestic request: ${JSON.stringify({ eventType: 'domestic_request', context })}`);
-
-    let response = await this.httpHandler.handle(context).catch<HttpHandlerResponse<string>>((error) => {
+    let response = await this.httpHandler.handle(httpHandlerRequest).catch<HttpHandlerResponse<string>>((error) => {
       const status = error?.statusCode ?? error.status;
       const message = error?.message ?? error.body;
 
