feat: Convert data from ResourceStore based on preferences

src/storage/conversion/ConversionUtil.ts

@@ -0,0 +1,47 @@
+import { matchingMediaType } from '../../util/Util';
+import { RepresentationConverterArgs } from './RepresentationConverter';
+import { RepresentationPreference } from '../../ldp/representation/RepresentationPreference';
+import { RepresentationPreferences } from '../../ldp/representation/RepresentationPreferences';
+import { UnsupportedHttpError } from '../../util/errors/UnsupportedHttpError';
+
+/**
+ * Filters out the media types from the preferred types that correspond to one of the supported types.
+ * @param preferences - Preferences for output type.
+ * @param supported - Types supported by the parser.
+ *
+ * @throws UnsupportedHttpError
+ * If the type preferences are undefined.
+ *
+ * @returns The filtered list of preferences.
+ */
+export const matchingTypes = (preferences: RepresentationPreferences, supported: string[]):
+RepresentationPreference[] => {
+  if (!Array.isArray(preferences.type)) {
+    throw new UnsupportedHttpError('Output type required for conversion.');
+  }
+  return preferences.type.filter(({ value, weight }): boolean => weight > 0 &&
+    supported.some((type): boolean => matchingMediaType(value, type)));
+};
+
+/**
+ * Runs some standard checks on the input request:
+ *  - Checks if there is a content type for the input.
+ *  - Checks if the input type is supported by the parser.
+ *  - Checks if the parser can produce one of the preferred output types.
+ * @param request - Incoming arguments.
+ * @param supportedIn - Media types that can be parsed by the converter.
+ * @param supportedOut - Media types that can be produced by the converter.
+ */
+export const checkRequest = (request: RepresentationConverterArgs, supportedIn: string[], supportedOut: string[]):
+void => {
+  const inType = request.representation.metadata.contentType;
+  if (!inType) {
+    throw new UnsupportedHttpError('Input type required for conversion.');
+  }
+  if (!supportedIn.some((type): boolean => matchingMediaType(inType, type))) {
+    throw new UnsupportedHttpError(`Can only convert from ${supportedIn} to ${supportedOut}.`);
+  }
+  if (matchingTypes(request.preferences, supportedOut).length <= 0) {
+    throw new UnsupportedHttpError(`Can only convert from ${supportedIn} to ${supportedOut}.`);
+  }
+};

src/storage/conversion/QuadToTurtleConverter.ts

@@ -0,0 +1,28 @@
+import { checkRequest } from './ConversionUtil';
+import { Representation } from '../../ldp/representation/Representation';
+import { RepresentationMetadata } from '../../ldp/representation/RepresentationMetadata';
+import { StreamWriter } from 'n3';
+import { CONTENT_TYPE_QUADS, DATA_TYPE_BINARY } from '../../util/ContentTypes';
+import { RepresentationConverter, RepresentationConverterArgs } from './RepresentationConverter';
+
+/**
+ * Converts `internal/quads` to `text/turtle`.
+ */
+export class QuadToTurtleConverter extends RepresentationConverter {
+  public async canHandle(input: RepresentationConverterArgs): Promise<void> {
+    checkRequest(input, [ CONTENT_TYPE_QUADS ], [ 'text/turtle' ]);
+  }
+
+  public async handle(input: RepresentationConverterArgs): Promise<Representation> {
+    return this.quadsToTurtle(input.representation);
+  }
+
+  private quadsToTurtle(quads: Representation): Representation {
+    const metadata: RepresentationMetadata = { ...quads.metadata, contentType: 'text/turtle' };
+    return {
+      dataType: DATA_TYPE_BINARY,
+      data: quads.data.pipe(new StreamWriter({ format: 'text/turtle' })),
+      metadata,
+    };
+  }
+}

src/storage/conversion/RepresentationConverter.ts

@@ -0,0 +1,24 @@
+import { AsyncHandler } from '../../util/AsyncHandler';
+import { Representation } from '../../ldp/representation/Representation';
+import { RepresentationPreferences } from '../../ldp/representation/RepresentationPreferences';
+import { ResourceIdentifier } from '../../ldp/representation/ResourceIdentifier';
+
+export interface RepresentationConverterArgs {
+  /**
+   * Identifier of the resource. Can be used as base IRI.
+   */
+  identifier: ResourceIdentifier;
+  /**
+   * Representation to convert.
+   */
+  representation: Representation;
+  /**
+   * Preferences indicating what is requested.
+   */
+  preferences: RepresentationPreferences;
+}
+
+/**
+ * Converts a {@link Representation} from one media type to another, based on the given preferences.
+ */
+export abstract class RepresentationConverter extends AsyncHandler<RepresentationConverterArgs, Representation> {}

src/storage/conversion/TurtleToQuadConverter.ts

@@ -0,0 +1,38 @@
+import { checkRequest } from './ConversionUtil';
+import { PassThrough } from 'stream';
+import { Representation } from '../../ldp/representation/Representation';
+import { RepresentationMetadata } from '../../ldp/representation/RepresentationMetadata';
+import { StreamParser } from 'n3';
+import { UnsupportedHttpError } from '../../util/errors/UnsupportedHttpError';
+import { CONTENT_TYPE_QUADS, DATA_TYPE_QUAD } from '../../util/ContentTypes';
+import { RepresentationConverter, RepresentationConverterArgs } from './RepresentationConverter';
+
+/**
+ * Converts `text/turtle` to `internal/quads`.
+ */
+export class TurtleToQuadConverter extends RepresentationConverter {
+  public async canHandle(input: RepresentationConverterArgs): Promise<void> {
+    checkRequest(input, [ 'text/turtle' ], [ CONTENT_TYPE_QUADS ]);
+  }
+
+  public async handle(input: RepresentationConverterArgs): Promise<Representation> {
+    return this.turtleToQuads(input.representation, input.identifier.path);
+  }
+
+  private turtleToQuads(turtle: Representation, baseIRI: string): Representation {
+    const metadata: RepresentationMetadata = { ...turtle.metadata, contentType: CONTENT_TYPE_QUADS };
+
+    // Catch parsing errors and emit correct error
+    // Node 10 requires both writableObjectMode and readableObjectMode
+    const errorStream = new PassThrough({ writableObjectMode: true, readableObjectMode: true });
+    const data = turtle.data.pipe(new StreamParser({ format: 'text/turtle', baseIRI }));
+    data.pipe(errorStream);
+    data.on('error', (error): boolean => errorStream.emit('error', new UnsupportedHttpError(error.message)));
+
+    return {
+      dataType: DATA_TYPE_QUAD,
+      data: errorStream,
+      metadata,
+    };
+  }
+}