feat: Integrate MetadataHandler

config/config-default.json

@@ -5,6 +5,7 @@
     "files-scs:config/presets/http.json",
     "files-scs:config/presets/ldp.json",
     "files-scs:config/presets/ldp/credentials-extractor.json",
+    "files-scs:config/presets/ldp/metadata-handler.json",
     "files-scs:config/presets/ldp/operation-handler.json",
     "files-scs:config/presets/ldp/permissions-extractor.json",
     "files-scs:config/presets/ldp/request-parser.json",

config/presets/ldp/metadata-handler.json

@@ -0,0 +1,20 @@
+{
+  "@context": "https://linkedsoftwaredependencies.org/bundles/npm/@solid/community-server/^1.0.0/components/context.jsonld",
+  "@graph": [
+    {
+      "@id": "urn:solid-server:default:MetadataExtractor",
+      "@type": "BasicMetadataExtractor",
+      "BasicMetadataExtractor:_parsers": [
+        {
+          "@type": "ContentTypeParser"
+        },
+        {
+          "@type": "LinkTypeParser"
+        },
+        {
+          "@type": "SlugParser"
+        }
+      ]
+    }
+  ]
+}

config/presets/ldp/request-parser.json

@@ -10,6 +10,9 @@
       "BasicRequestParser:_preferenceParser": {
         "@type": "AcceptPreferenceParser"
       },
+      "BasicRequestParser:_metadataExtractor": {
+        "@id": "urn:solid-server:default:MetadataExtractor"
+      },
       "BasicRequestParser:_bodyParser": {
         "@type": "CompositeAsyncHandler",
         "CompositeAsyncHandler:_handlers": [

index.ts

@@ -14,6 +14,14 @@ export * from './src/authorization/WebAclAuthorizer';
 export * from './src/init/CliRunner';
 export * from './src/init/Setup';
 
+// LDP/HTTP/Metadata
+export * from './src/ldp/http/metadata/BasicMetadataExtractor';
+export * from './src/ldp/http/metadata/ContentTypeParser';
+export * from './src/ldp/http/metadata/LinkTypeParser';
+export * from './src/ldp/http/metadata/MetadataExtractor';
+export * from './src/ldp/http/metadata/MetadataParser';
+export * from './src/ldp/http/metadata/SlugParser';
+
 // LDP/HTTP
 export * from './src/ldp/http/AcceptPreferenceParser';
 export * from './src/ldp/http/BasicRequestParser';

src/ldp/http/BasicRequestParser.ts

@@ -1,6 +1,7 @@
 import type { HttpRequest } from '../../server/HttpRequest';
 import type { Operation } from '../operations/Operation';
 import type { BodyParser } from './BodyParser';
+import type { MetadataExtractor } from './metadata/MetadataExtractor';
 import type { PreferenceParser } from './PreferenceParser';
 import { RequestParser } from './RequestParser';
 import type { TargetExtractor } from './TargetExtractor';
@@ -11,16 +12,18 @@ import type { TargetExtractor } from './TargetExtractor';
 export interface SimpleRequestParserArgs {
   targetExtractor: TargetExtractor;
   preferenceParser: PreferenceParser;
+  metadataExtractor: MetadataExtractor;
   bodyParser: BodyParser;
 }
 
 /**
  * Creates an {@link Operation} from an incoming {@link HttpRequest} by aggregating the results
- * of a {@link TargetExtractor}, {@link PreferenceParser}, and {@link BodyParser}.
+ * of a {@link TargetExtractor}, {@link PreferenceParser}, {@link MetadataExtractor}, and {@link BodyParser}.
  */
 export class BasicRequestParser extends RequestParser {
   private readonly targetExtractor!: TargetExtractor;
   private readonly preferenceParser!: PreferenceParser;
+  private readonly metadataExtractor!: MetadataExtractor;
   private readonly bodyParser!: BodyParser;
 
   public constructor(args: SimpleRequestParserArgs) {
@@ -38,7 +41,8 @@ export class BasicRequestParser extends RequestParser {
     }
     const target = await this.targetExtractor.handleSafe(input);
     const preferences = await this.preferenceParser.handleSafe(input);
-    const body = await this.bodyParser.handleSafe(input);
+    const metadata = await this.metadataExtractor.handleSafe(input);
+    const body = await this.bodyParser.handleSafe({ request: input, metadata });
 
     return { method: input.method, target, preferences, body };
   }

src/ldp/http/BodyParser.ts

@@ -1,8 +1,22 @@
 import type { HttpRequest } from '../../server/HttpRequest';
 import { AsyncHandler } from '../../util/AsyncHandler';
 import type { Representation } from '../representation/Representation';
+import type { RepresentationMetadata } from '../representation/RepresentationMetadata';
+
+export interface BodyParserArgs {
+  /**
+   * Request that contains the (potential) body.
+   */
+  request: HttpRequest;
+  /**
+   * Metadata that has already been parsed from the request.
+   * Can be updated by the BodyParser with extra metadata.
+   */
+  metadata: RepresentationMetadata;
+}
 
 /**
  * Parses the body of an incoming {@link HttpRequest} and converts it to a {@link Representation}.
  */
-export abstract class BodyParser extends AsyncHandler<HttpRequest, Representation | undefined> {}
+export abstract class BodyParser extends
+  AsyncHandler<BodyParserArgs, Representation | undefined> {}

src/ldp/http/RawBodyParser.ts

@@ -1,14 +1,10 @@
-import type { HttpRequest } from '../../server/HttpRequest';
 import { UnsupportedHttpError } from '../../util/errors/UnsupportedHttpError';
-import { CONTENT_TYPE, HTTP, RDF } from '../../util/UriConstants';
 import type { Representation } from '../representation/Representation';
-import { RepresentationMetadata } from '../representation/RepresentationMetadata';
+import type { BodyParserArgs } from './BodyParser';
 import { BodyParser } from './BodyParser';
 
 /**
  * Converts incoming {@link HttpRequest} to a Representation without any further parsing.
- * Naively parses the mediatype from the content-type header.
- * Some other metadata is also generated, but this should probably be done in an external handler.
  */
 export class RawBodyParser extends BodyParser {
   public async canHandle(): Promise<void> {
@@ -17,56 +13,23 @@ export class RawBodyParser extends BodyParser {
 
   // Note that the only reason this is a union is in case the body is empty.
   // If this check gets moved away from the BodyParsers this union could be removed
-  public async handle(input: HttpRequest): Promise<Representation | undefined> {
+  public async handle({ request, metadata }: BodyParserArgs): Promise<Representation | undefined> {
     // RFC7230, §3.3: The presence of a message body in a request
     // is signaled by a Content-Length or Transfer-Encoding header field.
-    if (!input.headers['content-length'] && !input.headers['transfer-encoding']) {
+    if (!request.headers['content-length'] && !request.headers['transfer-encoding']) {
       return;
     }
 
     // While RFC7231 allows treating a body without content type as an octet stream,
     // such an omission likely signals a mistake, so force clients to make this explicit.
-    if (!input.headers['content-type']) {
+    if (!request.headers['content-type']) {
       throw new UnsupportedHttpError('An HTTP request body was passed without Content-Type header');
     }
 
     return {
       binary: true,
-      data: input,
-      metadata: this.parseMetadata(input),
+      data: request,
+      metadata,
     };
   }
-
-  private parseMetadata(input: HttpRequest): RepresentationMetadata {
-    const contentType = /^[^;]*/u.exec(input.headers['content-type']!)![0];
-
-    const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: contentType });
-
-    const { link, slug } = input.headers;
-
-    if (slug) {
-      if (Array.isArray(slug)) {
-        throw new UnsupportedHttpError('At most 1 slug header is allowed.');
-      }
-      metadata.set(HTTP.slug, slug);
-    }
-
-    // There are similarities here to Accept header parsing so that library should become more generic probably
-    if (link) {
-      const linkArray = Array.isArray(link) ? link : [ link ];
-      const parsedLinks = linkArray.map((entry): { url: string; rel: string } => {
-        const [ , url, rest ] = /^<([^>]*)>(.*)$/u.exec(entry) ?? [];
-        const [ , rel ] = /^ *; *rel="(.*)"$/u.exec(rest) ?? [];
-        return { url, rel };
-      });
-      for (const entry of parsedLinks) {
-        if (entry.rel === 'type') {
-          metadata.set(RDF.type, entry.url);
-          break;
-        }
-      }
-    }
-
-    return metadata;
-  }
 }

src/ldp/http/SparqlUpdateBodyParser.ts

@@ -1,53 +1,50 @@
 import { PassThrough } from 'stream';
+import type { Algebra } from 'sparqlalgebrajs';
 import { translate } from 'sparqlalgebrajs';
-import type { HttpRequest } from '../../server/HttpRequest';
 import { APPLICATION_SPARQL_UPDATE } from '../../util/ContentTypes';
 import { UnsupportedHttpError } from '../../util/errors/UnsupportedHttpError';
 import { UnsupportedMediaTypeHttpError } from '../../util/errors/UnsupportedMediaTypeHttpError';
-import { CONTENT_TYPE } from '../../util/UriConstants';
-import { readableToString } from '../../util/Util';
-import { RepresentationMetadata } from '../representation/RepresentationMetadata';
+import { pipeStreamsAndErrors, readableToString } from '../../util/Util';
+import type { BodyParserArgs } from './BodyParser';
 import { BodyParser } from './BodyParser';
 import type { SparqlUpdatePatch } from './SparqlUpdatePatch';
 
 /**
  * {@link BodyParser} that supports `application/sparql-update` content.
  * Will convert the incoming update string to algebra in a {@link SparqlUpdatePatch}.
- * Still needs access to a handler for parsing metadata.
  */
 export class SparqlUpdateBodyParser extends BodyParser {
-  public async canHandle(input: HttpRequest): Promise<void> {
-    if (input.headers['content-type'] !== APPLICATION_SPARQL_UPDATE) {
+  public async canHandle({ request }: BodyParserArgs): Promise<void> {
+    if (request.headers['content-type'] !== APPLICATION_SPARQL_UPDATE) {
       throw new UnsupportedMediaTypeHttpError('This parser only supports SPARQL UPDATE data.');
     }
   }
 
-  public async handle(input: HttpRequest): Promise<SparqlUpdatePatch> {
+  public async handle({ request, metadata }: BodyParserArgs): Promise<SparqlUpdatePatch> {
+    // Note that readableObjectMode is only defined starting from Node 12
+    // It is impossible to check if object mode is enabled in Node 10 (without accessing private variables)
+    const options = { objectMode: request.readableObjectMode };
+    const toAlgebraStream = new PassThrough(options);
+    const dataCopy = new PassThrough(options);
+    pipeStreamsAndErrors(request, toAlgebraStream);
+    pipeStreamsAndErrors(request, dataCopy);
+    let algebra: Algebra.Operation;
     try {
-      // Note that readableObjectMode is only defined starting from Node 12
-      // It is impossible to check if object mode is enabled in Node 10 (without accessing private variables)
-      const options = { objectMode: input.readableObjectMode };
-      const toAlgebraStream = new PassThrough(options);
-      const dataCopy = new PassThrough(options);
-      input.pipe(toAlgebraStream);
-      input.pipe(dataCopy);
       const sparql = await readableToString(toAlgebraStream);
-      const algebra = translate(sparql, { quads: true });
-
-      const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: APPLICATION_SPARQL_UPDATE });
-
-      // Prevent body from being requested again
-      return {
-        algebra,
-        binary: true,
-        data: dataCopy,
-        metadata,
-      };
+      algebra = translate(sparql, { quads: true });
     } catch (error: unknown) {
       if (error instanceof Error) {
         throw new UnsupportedHttpError(error.message);
       }
       throw new UnsupportedHttpError();
     }
+
+    // Prevent body from being requested again
+    return {
+      algebra,
+      binary: true,
+      data: dataCopy,
+      metadata,
+    };
   }
 }

test/configs/BasicHandlersConfig.ts

@@ -15,10 +15,13 @@ import {
 } from '../../index';
 
 import type { ServerConfig } from './ServerConfig';
-import { getInMemoryResourceStore,
+import {
+  getInMemoryResourceStore,
   getOperationHandler,
   getConvertingStore,
-  getPatchingStore, getBasicRequestParser } from './Util';
+  getPatchingStore,
+  getBasicRequestParser,
+} from './Util';
 
 /**
  * BasicHandlersConfig works with

test/configs/FileResourceStoreConfig.ts

@@ -12,7 +12,12 @@ import {
   UnsecureWebIdExtractor,
 } from '../../index';
 import type { ServerConfig } from './ServerConfig';
-import { getFileResourceStore, getOperationHandler, getConvertingStore, getBasicRequestParser } from './Util';
+import {
+  getFileResourceStore,
+  getOperationHandler,
+  getConvertingStore,
+  getBasicRequestParser,
+} from './Util';
 
 /**
  * FileResourceStoreConfig works with

test/configs/Util.ts

@@ -1,21 +1,22 @@
 import { join } from 'path';
 import type { BodyParser,
-  HttpRequest,
   Operation,
-  Representation,
   RepresentationConverter,
   ResourceStore,
   ResponseDescription } from '../../index';
 import {
   AcceptPreferenceParser,
+  BasicMetadataExtractor,
   BasicRequestParser,
   BasicTargetExtractor,
   CompositeAsyncHandler,
+  ContentTypeParser,
   DeleteOperationHandler,
   FileResourceStore,
   GetOperationHandler,
   InMemoryResourceStore,
   InteractionController,
+  LinkTypeParser,
   MetadataController,
   PatchingStore,
   PatchOperationHandler,
@@ -24,6 +25,7 @@ import {
   RawBodyParser,
   RepresentationConvertingStore,
   SingleThreadedResourceLocker,
+  SlugParser,
   SparqlUpdatePatchHandler,
   UrlBasedAclManager,
   UrlContainerManager,
@@ -102,6 +104,15 @@ export const getOperationHandler = (store: ResourceStore): CompositeAsyncHandler
   return new CompositeAsyncHandler<Operation, ResponseDescription>(handlers);
 };
 
+/**
+ * Creates a BasicMetadataExtractor with parsers for content-type, slugs and link types.
+ */
+export const getBasicMetadataExtractor = (): BasicMetadataExtractor => new BasicMetadataExtractor([
+  new ContentTypeParser(),
+  new SlugParser(),
+  new LinkTypeParser(),
+]);
+
 /**
  * Gives a basic request parser based on some body parses.
  * @param bodyParsers - Optional list of body parsers, default is RawBodyParser.
@@ -116,11 +127,12 @@ export const getBasicRequestParser = (bodyParsers: BodyParser[] = []): BasicRequ
     // If no body parser is given (array is empty), default to RawBodyParser
     bodyParser = new RawBodyParser();
   } else {
-    bodyParser = new CompositeAsyncHandler<HttpRequest, Representation | undefined>(bodyParsers);
+    bodyParser = new CompositeAsyncHandler(bodyParsers);
   }
   return new BasicRequestParser({
     targetExtractor: new BasicTargetExtractor(),
     preferenceParser: new AcceptPreferenceParser(),
+    metadataExtractor: getBasicMetadataExtractor(),
     bodyParser,
   });
 };

test/integration/RequestParser.test.ts

@@ -4,15 +4,18 @@ import streamifyArray from 'streamify-array';
 import { AcceptPreferenceParser } from '../../src/ldp/http/AcceptPreferenceParser';
 import { BasicRequestParser } from '../../src/ldp/http/BasicRequestParser';
 import { BasicTargetExtractor } from '../../src/ldp/http/BasicTargetExtractor';
+import { BasicMetadataExtractor } from '../../src/ldp/http/metadata/BasicMetadataExtractor';
+import { ContentTypeParser } from '../../src/ldp/http/metadata/ContentTypeParser';
 import { RawBodyParser } from '../../src/ldp/http/RawBodyParser';
 import { RepresentationMetadata } from '../../src/ldp/representation/RepresentationMetadata';
 import type { HttpRequest } from '../../src/server/HttpRequest';
 
 describe('A BasicRequestParser with simple input parsers', (): void => {
   const targetExtractor = new BasicTargetExtractor();
-  const bodyParser = new RawBodyParser();
   const preferenceParser = new AcceptPreferenceParser();
-  const requestParser = new BasicRequestParser({ targetExtractor, bodyParser, preferenceParser });
+  const metadataExtractor = new BasicMetadataExtractor([ new ContentTypeParser() ]);
+  const bodyParser = new RawBodyParser();
+  const requestParser = new BasicRequestParser({ targetExtractor, preferenceParser, metadataExtractor, bodyParser });
 
   it('can parse an incoming request.', async(): Promise<void> => {
     const request = streamifyArray([ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ]) as HttpRequest;