feat: allow individual article retrieval

Generates a unique IRI for each article, and allows them to be accessed individually.

src/router.ts

@@ -3,6 +3,7 @@ import { AppServiceContext, AppState } from './app';
 import Routes from './routes';
 import addArticle from './routes/add-article';
 import apiDocumentation from './routes/api-documentation';
+import article from './routes/article';
 import articleList from './routes/article-list';
 import entryPoint from './routes/entry-point';
 
@@ -12,6 +13,7 @@ export default (): Router<AppState, AppServiceContext> => {
   router.get(Routes.ApiDocumentation, '/doc', apiDocumentation());
   router.get(Routes.ArticleList, '/articles', articleList());
   router.post(Routes.AddArticle, '/articles', addArticle());
+  router.get(Routes.Article, '/articles/:id', article());
   router.get(Routes.EntryPoint, '/', entryPoint());
 
   return router;

src/routes/add-article.ts

@@ -28,7 +28,7 @@ export default (): AppMiddleware => (
       throw new createHttpError.BadRequest(`Article must have at least one ${termToString(schema('name'))}`);
     }
 
-    const newId = namedNode(uniqueString());
+    const newId = namedNode(url.resolve(request.origin, router.url(Routes.Article, uniqueString())));
 
     [...request.dataset].forEach((originalQuad: Quad): void => {
       let newQuad: Quad;
@@ -46,7 +46,7 @@ export default (): AppMiddleware => (
     await articles.set(newId, request.dataset);
 
     response.status = CREATED;
-    response.set('Location', url.resolve(request.origin, router.url(Routes.ArticleList)));
+    response.set('Location', newId.value);
 
     await next();
   }

src/routes/article.ts

@@ -0,0 +1,28 @@
+import createHttpError from 'http-errors';
+import { OK } from 'http-status-codes';
+import { Next } from 'koa';
+import url from 'url';
+import { AppContext, AppMiddleware } from '../app';
+import ArticleNotFound from '../errors/article-not-found';
+
+export default (): AppMiddleware => (
+  async ({
+    articles, dataFactory: { namedNode }, request, response,
+  }: AppContext, next: Next): Promise<void> => {
+    const id = namedNode(url.resolve(request.origin, request.path));
+
+    try {
+      response.dataset = await articles.get(id);
+    } catch (error) {
+      if (error instanceof ArticleNotFound) {
+        throw new createHttpError.NotFound(error.message);
+      }
+
+      throw error;
+    }
+
+    response.status = OK;
+
+    await next();
+  }
+);

src/routes/index.ts

@@ -1,6 +1,7 @@
 enum Routes {
   'AddArticle' = 'add-article',
   'ApiDocumentation' = 'api-documentation',
+  'Article' = 'article',
   'ArticleList' = 'article-list',
   'EntryPoint' = 'entry-point',
 }

test/routes/add-article.test.ts

@@ -30,11 +30,11 @@ describe('add article', (): void => {
     const response = await makeRequest(createArticle({ id, name }), undefined, articles);
 
     expect(response.status).toBe(CREATED);
-    expect(response.get('Location')).toBe('http://example.com/path-to/article-list');
     expect(await articles.count()).toBe(1);
 
     const [newId, dataset] = (await all(articles))[0];
 
+    expect(response.get('Location')).toBe(newId.value);
     expect(dataset.has(quad(newId, schema('name'), name))).toBe(true);
   });
 

test/routes/article.test.ts

@@ -0,0 +1,59 @@
+import { namedNode } from '@rdfjs/data-model';
+import createHttpError from 'http-errors';
+import { OK } from 'http-status-codes';
+import 'jest-rdf';
+import { Response } from 'koa';
+import InMemoryArticles from '../../src/adaptors/in-memory-articles';
+import Articles from '../../src/articles';
+import { WithDataset } from '../../src/middleware/dataset';
+import article from '../../src/routes/article';
+import createContext from '../context';
+import createArticle from '../create-article';
+import runMiddleware, { NextMiddleware } from '../middleware';
+
+const makeRequest = async (
+  path: string, articles?: Articles, next?: NextMiddleware,
+): Promise<WithDataset<Response>> => (
+  runMiddleware(article(), createContext({ articles, path }), next)
+);
+
+describe('article', (): void => {
+  it('should return a successful response', async (): Promise<void> => {
+    const id = namedNode('http://example.com/path-to/article/one');
+    const articles = new InMemoryArticles();
+    await articles.set(id, createArticle({ id }));
+
+    const response = await makeRequest('path-to/article/one', articles);
+
+    expect(response.status).toBe(OK);
+  });
+
+  it('should return the article', async (): Promise<void> => {
+    const id = namedNode('http://example.com/path-to/article/one');
+    const articles = new InMemoryArticles();
+    const article1 = createArticle({ id });
+    await articles.set(id, article1);
+
+    const response = await makeRequest('path-to/article/one', articles);
+
+    expect([...response.dataset]).toEqualRdfQuadArray([...article1]);
+  });
+
+  it('should throw an error if article is not found', async (): Promise<void> => {
+    const response = makeRequest('path-to/article/not-found');
+
+    await expect(response).rejects.toBeInstanceOf(createHttpError.NotFound);
+    await expect(response).rejects.toHaveProperty('message', 'Article http://example.com/path-to/article/not-found could not be found');
+  });
+
+  it('should call the next middleware', async (): Promise<void> => {
+    const id = namedNode('http://example.com/path-to/article/one');
+    const articles = new InMemoryArticles();
+    await articles.set(id, createArticle({ id }));
+    const next = jest.fn();
+
+    await makeRequest('path-to/article/one', articles, next);
+
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+});