Uses Iri as NamedNode value and allow individual article retrieval

src/app.ts

@@ -11,6 +11,7 @@ import errorHandler from './middleware/error-handler';
 import jsonld from './middleware/jsonld';
 import routing from './middleware/routing';
 import namespaces from './namespaces';
+import article from './routes/article';
 
 export type AppState = DefaultState;
 
@@ -48,6 +49,7 @@ export default (
   }));
   app.use(apiDocumentationLink(apiDocumentationPath));
   app.use(errorHandler());
+  app.use(article());
   app.use(routing(router));
 
   return app;

src/routes/add-article.ts

@@ -8,11 +8,10 @@ import uniqueString from 'unique-string';
 import url from 'url';
 import { AppContext, AppMiddleware } from '../app';
 import { rdf, schema } from '../namespaces';
-import Routes from './index';
 
 export default (): AppMiddleware => (
   async ({
-    articles, dataFactory: { namedNode, quad }, request, response, router,
+    articles, dataFactory: { namedNode, quad }, request, response,
   }: AppContext, next: Next): Promise<void> => {
     const id = clownface({ dataset: request.dataset }).has(rdf.type, schema.Article).term;
 
@@ -28,7 +27,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, 'articles/'.concat(uniqueString())));
 
     [...request.dataset].forEach((originalQuad: Quad): void => {
       let newQuad: Quad;
@@ -46,7 +45,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,35 @@
+import createHttpError from 'http-errors';
+import { OK } from 'http-status-codes';
+import {
+  DefaultStateExtends, Middleware, Next,
+} from 'koa';
+import url from 'url';
+import { AppContext } from '../app';
+import { namedNode } from '../data-factory';
+import ArticleNotFound from '../errors/article-not-found';
+
+export default (): Middleware<DefaultStateExtends, AppContext> => (
+  async ({
+    path, articles, request, response,
+  }: AppContext, next: Next): Promise<void> => {
+    try {
+      await next();
+    } catch (error) {
+      if (!(error instanceof createHttpError.NotFound)) {
+        throw error;
+      }
+
+      try {
+        response.dataset = await articles.get(namedNode(url.resolve(request.origin, path)));
+      } catch (getError) {
+        if (getError instanceof ArticleNotFound) {
+          throw new createHttpError.NotFound(getError.message);
+        }
+
+        throw getError;
+      }
+
+      response.status = OK;
+    }
+  }
+);

test/context.ts

@@ -22,6 +22,7 @@ type Options = {
   method?: string;
   path?: string;
   router?: Router;
+  url?: string;
 };
 
 const dummyRouter = {

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,75 @@
+import {
+  namedNode,
+} from '@rdfjs/data-model';
+import createHttpError from 'http-errors';
+import { OK } from 'http-status-codes';
+import { Response } from 'koa';
+import InMemoryArticles from '../../src/adaptors/in-memory-articles';
+import Articles from '../../src/articles';
+import article from '../../src/routes/article';
+import createContext from '../context';
+import createArticle from '../create-article';
+import runMiddleware, { NextMiddleware } from '../middleware';
+import { WithDataset } from '../../src/middleware/dataset';
+
+const dummyNext = async (): Promise<void> => {
+  throw new createHttpError.NotFound();
+};
+
+const makeRequest = async (
+  path: string,
+  articles?: Articles,
+  next?: NextMiddleware,
+): Promise<WithDataset<Response>> => (
+  runMiddleware(article(), createContext({ articles, path }), typeof next !== 'undefined' ? next : dummyNext)
+);
+
+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 not attempt article retrieval when next middleware throws not found http error', async (): Promise<void> => {
+    const mockArticles: Articles = {
+      set: jest.fn(),
+      get: jest.fn(),
+      remove: jest.fn(),
+      contains: jest.fn(),
+      count: jest.fn(),
+      [Symbol.asyncIterator]: jest.fn(),
+    };
+
+    const next = jest.fn();
+    await makeRequest('path-to/article/one', mockArticles, next);
+    expect(mockArticles.get).toHaveBeenCalledTimes(0);
+  });
+
+  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 throw error raised in next middleware', async (): Promise<void> => {
+    const next = async (): Promise<void> => {
+      throw new createHttpError.BadRequest();
+    };
+    const response = makeRequest('path-to/article/not-found', undefined, next);
+
+    await expect(response).rejects.toBeInstanceOf(createHttpError.BadRequest);
+  });
+
+  it('should call the next middleware', async (): Promise<void> => {
+    const next = jest.fn();
+    await makeRequest('path-to/article/one', undefined, next);
+
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+});