feat: add simple body parser

Author: joachimvh

.eslintignore

@@ -7,3 +7,5 @@ coverage
 **/*.js
 **/*.d.ts
 **/*.js.map
+
+!external-types/*.d.ts

.eslintrc.js

@@ -16,6 +16,7 @@ module.exports = {
     '@typescript-eslint/space-before-function-paren': [ 'error', 'never' ],
     'class-methods-use-this': 'off',
     'comma-dangle': ['error', 'always-multiline'],
+    'dot-location': ['error', 'property'],
     'lines-between-class-members': ['error', 'always', { exceptAfterSingleLine: true }],
     'padding-line-between-statements': 'off',
     'tsdoc/syntax': 'error',

.gitignore

@@ -9,3 +9,4 @@ coverage
 !.eslintrc.js
 !test/eslintrc.js
 !jest.config.js
+!external-types/*.d.ts

external-types/arrayifyStream.d.ts

@@ -0,0 +1,6 @@
+declare module 'arrayify-stream' {
+  import { Readable } from 'stream';
+
+  function arrayifyStream(input: Readable): Promise<any[]>;
+  export = arrayifyStream;
+}

external-types/streamifyArray.d.ts

@@ -0,0 +1,6 @@
+declare module 'streamify-array' {
+  import { Readable } from 'stream';
+
+  function streamifyArray(input: any[]): Readable;
+  export = streamifyArray;
+}

jest.config.js

@@ -13,6 +13,7 @@ module.exports = {
     "js"
   ],
   "testEnvironment": "node",
+  "setupFilesAfterEnv": ["jest-rdf"],
   "collectCoverage": true,
   "coveragePathIgnorePatterns": [
     "/node_modules/"

package-lock.json

@@ -22,18 +22,23 @@
   ],
   "dependencies": {
     "@rdfjs/data-model": "^1.1.2",
+    "@types/n3": "^1.1.6",
     "@types/node": "^14.0.1",
-    "@types/rdf-js": "^3.0.0"
+    "@types/rdf-js": "^3.0.0",
+    "n3": "^1.3.7"
   },
   "devDependencies": {
     "@types/jest": "^25.2.1",
     "@typescript-eslint/eslint-plugin": "^2.33.0",
     "@typescript-eslint/parser": "^2.33.0",
+    "arrayify-stream": "^1.0.0",
     "eslint": "^7.0.0",
     "eslint-config-es": "^3.19.61",
     "eslint-plugin-tsdoc": "^0.2.4",
     "husky": "^4.2.5",
     "jest": "^26.0.1",
+    "jest-rdf": "^1.5.0",
+    "streamify-array": "^1.0.1",
     "ts-jest": "^26.0.0",
     "typescript": "^3.9.2"
   }

package.json

@@ -0,0 +1,52 @@
+import { BodyParser } from './BodyParser';
+import { HttpRequest } from '../../server/HttpRequest';
+import { Quad } from 'rdf-js';
+import { QuadRepresentation } from '../representation/QuadRepresentation';
+import { RepresentationMetadata } from '../representation/RepresentationMetadata';
+import { StreamParser } from 'n3';
+import { TypedReadable } from '../../util/TypedReadable';
+import { UnsupportedMediaTypeHttpError } from '../../util/errors/UnsupportedMediaTypeHttpError';
+import 'jest-rdf';
+
+export class SimpleBodyParser extends BodyParser {
+  private static readonly contentTypes = [
+    'application/n-quads',
+    'application/trig',
+    'application/n-triples',
+    'text/turtle',
+    'text/n3',
+  ];
+
+  public async canHandle(input: HttpRequest): Promise<void> {
+    const contentType = input.headers['content-type'];
+
+    if (contentType && !SimpleBodyParser.contentTypes.some((type): boolean => contentType.includes(type))) {
+      throw new UnsupportedMediaTypeHttpError('This parser only supports RDF data.');
+    }
+  }
+
+  public async handle(input: HttpRequest): Promise<QuadRepresentation> {
+    const contentType = input.headers['content-type'];
+
+    if (!contentType) {
+      return undefined;
+    }
+
+    const specificType = contentType.split(';')[0];
+
+    const metadata: RepresentationMetadata = {
+      raw: [],
+      profiles: [],
+      contentType: specificType,
+    };
+
+    // StreamParser is a Readable but typings are incorrect at time of writing
+    const quads: TypedReadable<Quad> = input.pipe(new StreamParser()) as unknown as TypedReadable<Quad>;
+
+    return {
+      dataType: 'quad',
+      data: quads,
+      metadata,
+    };
+  }
+}

src/ldp/http/SimpleBodyParser.ts

@@ -0,0 +1,7 @@
+import { HttpError } from './HttpError';
+
+export class UnsupportedMediaTypeHttpError extends HttpError {
+  public constructor(message?: string) {
+    super(415, 'UnsupportedHttpError', message);
+  }
+}

src/util/errors/UnsupportedMediaTypeHttpError.ts

@@ -0,0 +1,58 @@
+import arrayifyStream from 'arrayify-stream';
+import { HttpRequest } from '../../../../src/server/HttpRequest';
+import { SimpleBodyParser } from '../../../../src/ldp/http/SimpleBodyParser';
+import streamifyArray from 'streamify-array';
+import { StreamParser } from 'n3';
+import { UnsupportedMediaTypeHttpError } from '../../../../src/util/errors/UnsupportedMediaTypeHttpError';
+import { namedNode, triple } from '@rdfjs/data-model';
+
+const contentTypes = [
+  'application/n-quads',
+  'application/trig',
+  'application/n-triples',
+  'text/turtle',
+  'text/n3',
+];
+
+describe('A SimpleBodyparser', (): void => {
+  const bodyParser = new SimpleBodyParser();
+
+  it('rejects input with unsupported content type.', async(): Promise<void> => {
+    await expect(bodyParser.canHandle({ headers: { 'content-type': 'application/rdf+xml' }} as HttpRequest))
+      .rejects.toThrow(new UnsupportedMediaTypeHttpError('This parser only supports RDF data.'));
+  });
+
+  it('accepts input with no content type.', async(): Promise<void> => {
+    await expect(bodyParser.canHandle({ headers: { }} as HttpRequest)).resolves.toBeUndefined();
+  });
+
+  it('accepts turtle and similar content types.', async(): Promise<void> => {
+    for (const type of contentTypes) {
+      await expect(bodyParser.canHandle({ headers: { 'content-type': type }} as HttpRequest)).resolves.toBeUndefined();
+    }
+  });
+
+  it('returns empty output if there was no content-type.', async(): Promise<void> => {
+    await expect(bodyParser.handle({ headers: { }} as HttpRequest)).resolves.toBeUndefined();
+  });
+
+  it('returns a stream of quads if there was data.', async(): Promise<void> => {
+    const input = streamifyArray([ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ]) as HttpRequest;
+    input.headers = { 'content-type': 'text/turtle' };
+    const result = await bodyParser.handle(input);
+    expect(result).toEqual({
+      data: expect.any(StreamParser),
+      dataType: 'quad',
+      metadata: {
+        contentType: 'text/turtle',
+        profiles: [],
+        raw: [],
+      },
+    });
+    await expect(arrayifyStream(result.data)).resolves.toEqualRdfQuadArray([ triple(
+      namedNode('http://test.com/s'),
+      namedNode('http://test.com/p'),
+      namedNode('http://test.com/o'),
+    ) ]);
+  });
+});

test/unit/ldp/http/SimpleBodyParser.test.ts

@@ -5,6 +5,7 @@
     "newLine": "lf",
     "alwaysStrict": true,
     "declaration": true,
+    "esModuleInterop": true,
     "inlineSources": true,
     "noImplicitAny": true,
     "noImplicitThis": true,
@@ -14,6 +15,7 @@
     "stripInternal": true
   },
   "include": [
+    "external-types/**/*.ts",
     "src/**/*.ts",
     "test/**/*.ts"
   ],