feat: Use CSS HttpHandlers and responses

Author: joachimvh

packages/uma/config/routes/resources.json

@@ -37,6 +37,12 @@
         },
         "idName": "id"
       }],
+      "parameterMap": [
+        {
+          "InteractionRouterHandler:_args_parameterMap_key": "id",
+          "InteractionRouterHandler:_args_parameterMap_value": "urn:custom:uma:id"
+        }
+      ],
       "handler": { "@id": "urn:uma:default:ResourceRegistrationHandler" }
     }
   ]

packages/uma/src/index.ts

@@ -59,9 +59,6 @@ export * from './util/ReType';
 
 // HTTP
 export * from './util/http/identifier/BaseTargetExtractor';
-export * from './util/http/models/HttpHandler';
-export * from './util/http/models/HttpHandlerRequest';
-export * from './util/http/models/HttpHandlerResponse';
 export * from './util/http/server/ErrorHandler';
 export * from './util/http/server/InteractionRouterHandler';
 export * from './util/http/server/NodeHttpRequestResponseHandler';

packages/uma/src/routes/Config.ts

@@ -1,9 +1,16 @@
 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 { HttpHandlerRequest } from '../util/http/models/HttpHandlerRequest';
-import { HttpHandlerResponse } from '../util/http/models/HttpHandlerResponse';
+import {
+  APPLICATION_JSON,
+  CONTENT_TYPE,
+  getLoggerFor,
+  guardedStreamFrom,
+  OkResponseDescription,
+  OperationHttpHandler,
+  OperationHttpHandlerInput,
+  RepresentationMetadata,
+  ResponseDescription
+} from '@solid/community-server';
 
 // eslint-disable no-unused-vars
 export enum ResponseType {
@@ -34,7 +41,7 @@ export type UmaConfiguration = OAuthConfiguration & {
  * An HttpHandler used for returning the configuration
  * of the UMA Authorization Service.
  */
-export class ConfigRequestHandler extends HttpHandler {
+export class ConfigRequestHandler extends OperationHttpHandler {
   protected readonly logger = getLoggerFor(this);
 
   /**
@@ -48,18 +55,14 @@ export class ConfigRequestHandler extends HttpHandler {
 
   /**
    * Returns the endpoint's UMA configuration
-   *
-   * @param {HttpHandlerRequest} request - an irrelevant incoming context
-   * @return {HttpHandlerResponse} - the mock response
-   */
-  async handle(request: HttpHandlerRequest): Promise<HttpHandlerResponse> {
-    this.logger.info(`Received discovery request at '${request.url}'`);
+   **/
+  public async handle(input: OperationHttpHandlerInput): Promise<ResponseDescription> {
+    this.logger.info(`Received discovery request at '${input.operation.target.path}'`);
 
-    return {
-      body: JSON.stringify(this.getConfig()),
-      headers: {'content-type': 'application/json'},
-      status: 200,
-    };
+    return new OkResponseDescription(
+      new RepresentationMetadata({[CONTENT_TYPE]: APPLICATION_JSON}),
+      guardedStreamFrom(JSON.stringify(this.getConfig()))
+    )
   }
 
   /**

packages/uma/src/routes/Introspection.ts

@@ -1,13 +1,19 @@
-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';
 import { SerializedToken } from '../tokens/TokenFactory';
 import {
+  APPLICATION_JSON,
   BadRequestHttpError,
+  CONTENT_TYPE,
   getLoggerFor,
-  JwkGenerator, KeyValueStorage,
+  guardedStreamFrom,
+  KeyValueStorage,
+  OkResponseDescription,
+  OperationHttpHandler,
+  OperationHttpHandlerInput,
+  readableToString,
+  RepresentationMetadata,
+  ResponseDescription,
   UnauthorizedHttpError,
   UnsupportedMediaTypeHttpError
 } from '@solid/community-server';
@@ -16,7 +22,7 @@ import { verifyRequest } from '../util/HttpMessageSignatures';
 /**
  * An HTTP handler that provides introspection into opaque access tokens.
  */
-export class IntrospectionHandler extends HttpHandler {
+export class IntrospectionHandler extends OperationHttpHandler {
   protected readonly logger = getLoggerFor(this);
 
   /**
@@ -34,36 +40,33 @@ export class IntrospectionHandler extends HttpHandler {
 
   /**
   * Handle incoming requests for token introspection
-  * @param {HttpHandlerRequest} request
-  * @return {HttpHandlerResponse}
   */
-  async handle(request: HttpHandlerRequest): Promise<HttpHandlerResponse<any>> {
-    if (!await verifyRequest(request)) throw new UnauthorizedHttpError();
+  public async handle(input: OperationHttpHandlerInput): Promise<ResponseDescription> {
+    if (!await verifyRequest(input.request, input.operation)) throw new UnauthorizedHttpError();
 
-    if (request.headers['content-type'] !== 'application/x-www-form-urlencoded') {
+    if (input.request.headers['content-type'] !== 'application/x-www-form-urlencoded') {
       throw new UnsupportedMediaTypeHttpError(
           'Only Media Type "application/x-www-form-urlencoded" is supported for this route.');
     }
 
-    if (request.headers['accept'] !== 'application/json') {
+    if (input.request.headers['accept'] !== 'application/json') {
       throw new UnsupportedMediaTypeHttpError(
           'Only "application/json" can be served by this route.');
     }
 
-    if (!request.body || !(request.body instanceof Object)) {
+    if (input.operation.body.isEmpty) {
       throw new BadRequestHttpError('Missing request body.');
     }
 
     try {
-      const opaqueToken = new URLSearchParams(request.body as Record<string, string>).get('token');
+      const opaqueToken = new URLSearchParams(await readableToString(input.operation.body.data)).get('token');
       if (!opaqueToken) throw new Error ();
 
-      const jwt = this.opaqueToJwt(opaqueToken);
-      return {
-        headers: {'content-type': 'application/json'},
-        status: 200,
-        body: jwt,
-      };
+      const jwt = await this.opaqueToJwt(opaqueToken);
+      return new OkResponseDescription(
+        new RepresentationMetadata({[CONTENT_TYPE]: APPLICATION_JSON}),
+        guardedStreamFrom(JSON.stringify(jwt)),
+      );
     } catch (e) {
       throw new BadRequestHttpError('Invalid request body.');
     }

packages/uma/src/routes/Jwks.ts

@@ -1,18 +1,26 @@
-import { HttpHandler } from '../util/http/models/HttpHandler';
-import { HttpHandlerRequest } from '../util/http/models/HttpHandlerRequest';
-import { HttpHandlerResponse } from '../util/http/models/HttpHandlerResponse';
-import { getLoggerFor, JwkGenerator } from '@solid/community-server';
+import {
+  APPLICATION_JSON,
+  CONTENT_TYPE,
+  getLoggerFor,
+  guardedStreamFrom,
+  JwkGenerator,
+  OkResponseDescription,
+  OperationHttpHandler,
+  OperationHttpHandlerInput,
+  RepresentationMetadata,
+  ResponseDescription
+} from '@solid/community-server';
 
 /**
  * An HttpHandler used for returning the configuration
  * of the UMA Authorization Service.
  */
-export class JwksRequestHandler extends HttpHandler {
+export class JwksRequestHandler extends OperationHttpHandler {
   protected readonly logger = getLoggerFor(this);
 
   /**
    * Yields a new request handler for JWKS
-   * @param {JwksKeyHolder} keyholder - the keyholder to be used for serving JWKS
+   * @param {JwkGenerator} generator - the generator to be used for serving JWKS
    */
   public constructor(
     private readonly generator: JwkGenerator
@@ -22,20 +30,15 @@ export class JwksRequestHandler extends HttpHandler {
 
   /**
      * Returns the JSON Web KeySet for specified keyholder
-     * @param {HttpHandlerRequest} request
-     * @return {HttpHandlerResponse} - the JWKS response
      */
-  async handle(request: HttpHandlerRequest): Promise<HttpHandlerResponse> {
-    this.logger.info(`Received JWKS request at '${request.url}'`);
+  async handle(request: OperationHttpHandlerInput): Promise<ResponseDescription> {
+    this.logger.info(`Received JWKS request at '${request.operation.target.path}'`);
 
     const key = await this.generator.getPublicKey();
 
-    return {
-      status: 200,
-      headers: {
-        'content-type': 'application/json'
-      },
-      body: JSON.stringify({ keys: [ key ] }),
-    };
+    return new OkResponseDescription(
+      new RepresentationMetadata({[CONTENT_TYPE]: APPLICATION_JSON}),
+      guardedStreamFrom(JSON.stringify({ keys: [ key ] }))
+    );
   }
 }

packages/uma/src/routes/ResourceRegistration.ts

@@ -1,16 +1,22 @@
 import {
+  APPLICATION_JSON,
   BadRequestHttpError,
+  CONTENT_TYPE,
   createErrorMessage,
   getLoggerFor,
+  guardedStreamFrom,
   KeyValueStorage,
   MethodNotAllowedHttpError,
+  OperationHttpHandler,
+  OperationHttpHandlerInput,
+  readableToString,
+  RepresentationMetadata,
+  ResponseDescription,
   UnauthorizedHttpError,
   UnsupportedMediaTypeHttpError
 } from '@solid/community-server';
-import {HttpHandler} from '../util/http/models/HttpHandler';
-import {HttpHandlerResponse} from '../util/http/models/HttpHandlerResponse';
 import {v4} from 'uuid';
-import { HttpHandlerRequest } from '../util/http/models/HttpHandlerRequest';
+import { CUSTOM_UMA } from '../util/Vocabularies';
 import { ResourceDescription } from '../views/ResourceDescription';
 import { reType } from '../util/ReType';
 import { extractRequestSigner, verifyRequest } from '../util/HttpMessageSignatures';
@@ -23,12 +29,9 @@ type ErrorConstructor = { new(msg: string): Error };
  *
  * It provides an endpoint to a Resource Server for registering its resources.
  */
-export class ResourceRegistrationRequestHandler extends HttpHandler {
+export class ResourceRegistrationRequestHandler extends OperationHttpHandler {
   protected readonly logger = getLoggerFor(this);
 
-  /**
-   * @param {RequestingPartyRegistration[]} resourceServers - Pod Servers to be registered with the UMA AS
-   */
   constructor(
     private readonly resourceStore: KeyValueStorage<string, ResourceDescription>,
   ) {
@@ -37,32 +40,30 @@ export class ResourceRegistrationRequestHandler extends HttpHandler {
 
   /**
   * Handle incoming requests for resource registration
-  * @param {HttpHandlerRequest} request
-  * @return {HttpHandlerResponse}
   */
-  async handle(request: HttpHandlerRequest): Promise<HttpHandlerResponse> {
-    const signer = await extractRequestSigner(request);
+  async handle(input: OperationHttpHandlerInput): Promise<ResponseDescription> {
+    const signer = await extractRequestSigner(input.request);
 
     // TODO: check if signer is actually the correct one
 
-    if (!await verifyRequest(request, signer)) {
+    if (!await verifyRequest(input.request, input.operation, signer)) {
       throw new UnauthorizedHttpError(`Failed to verify signature of <${signer}>`);
     }
 
-    switch (request.method) {
-      case 'POST': return this.handlePost(request);
-      case 'DELETE': return this.handleDelete(request);
+    switch (input.operation.method) {
+      case 'POST': return this.handlePost(input);
+      case 'DELETE': return this.handleDelete(input);
       default: throw new MethodNotAllowedHttpError();
     }
   }
 
-  private async handlePost(request: HttpHandlerRequest): Promise<HttpHandlerResponse<any>> {
-    const { headers, body } = request;
-
-    if (headers['content-type'] !== 'application/json') {
+  private async handlePost(input: OperationHttpHandlerInput): Promise<ResponseDescription> {
+    if (input.request.headers['content-type'] !== 'application/json') {
       throw new UnsupportedMediaTypeHttpError('Only Media Type "application/json" is supported for this route.');
     }
 
+    const body = JSON.parse(await readableToString(input.operation.body.data));
+
     try {
       reType(body, ResourceDescription);
     } catch (e) {
@@ -71,35 +72,31 @@ export class ResourceRegistrationRequestHandler extends HttpHandler {
     }
 
     const resource = v4();
-    this.resourceStore.set(resource, body);
+    await this.resourceStore.set(resource, body);
 
     this.logger.info(`Registered resource ${resource}.`);
 
-    return ({
-      status: 201,
-      headers: {
-        'content-type': 'application/json'
-      },
-      body: JSON.stringify({
+    return new ResponseDescription(
+      201,
+      new RepresentationMetadata({ [CONTENT_TYPE]: APPLICATION_JSON }),
+      guardedStreamFrom(JSON.stringify({
         _id: resource,
         user_access_policy_uri: 'TODO: implement policy UI',
-      }),
-    })
+      }))
+    );
   }
 
-  private async handleDelete({ parameters }: HttpHandlerRequest): Promise<HttpHandlerResponse<any>> {
-    if (typeof parameters?.id !== 'string') throw new Error('URI for DELETE operation should include an id.');
+  private async handleDelete(input: OperationHttpHandlerInput): Promise<ResponseDescription> {
+    const id = input.operation.body.metadata.get(CUSTOM_UMA.terms.id)?.value;
+    if (!id) throw new Error('URI for DELETE operation should include an id.');
 
-    if (!await this.resourceStore.has(parameters.id)) {
+    if (!await this.resourceStore.has(id)) {
       throw new Error('Registration to be deleted does not exist (id unknown).');
     }
 
-    this.logger.info(`Deleted resource ${parameters.id}.`);
+    this.logger.info(`Deleted resource ${id}.`);
 
-    return ({
-      status: 204,
-      headers: {},
-    });
+    return new ResponseDescription(204);
   }
 
   /**