feat: handler chains

packages/core/lib/Kopflos.ts

@@ -108,7 +108,7 @@ export default class Impl implements Kopflos {
     return this.graph.has(this.env.ns.rdf.type, this.env.ns.kopflos.Api)
   }
 
-  async getResponse(req: KopflosRequest<Dataset>): Promise<KopflosResponse> {
+  async getResponse(req: KopflosRequest<Dataset>): Promise<KopflosResponse | undefined | null> {
     const resourceShapeMatch = await this.findResourceShape(req.iri)
     if (isResponse(resourceShapeMatch)) {
       return resourceShapeMatch
@@ -139,22 +139,31 @@ export default class Impl implements Kopflos {
       args.property = resourceShapeMatch.property
       args.object = resourceGraph.node(resourceShapeMatch.object)
     }
-    const [handler, ...rest] = handlerChain
-    let response = this.asEnvelope(await handler(args, undefined))
-    for (const handler of rest) {
-      response = this.asEnvelope(await handler(args, response))
+
+    let handler = handlerChain.shift()
+    let response: ResultEnvelope | undefined
+    while (handler) {
+      const rawResult = await handler(args, response)
+      if (!rawResult) {
+        return rawResult
+      }
+
+      response = this.asEnvelope(rawResult)
       if (response.end) {
         break
       }
+
+      handler = handlerChain.shift()
     }
+
     return response
   }
 
   async handleRequest(req: KopflosRequest<Dataset>): Promise<ResultEnvelope> {
     log.info(`${req.method} ${req.iri.value}`)
     log.debug('Request headers', req.headers)
 
-    let result: KopflosResponse
+    let result: KopflosResponse | undefined | null
     try {
       result = await this.getResponse(req)
     } catch (cause: Error | unknown) {
@@ -171,7 +180,7 @@ export default class Impl implements Kopflos {
     }
 
     if (!result) {
-      log.error('Undefined result returned from handler')
+      log.error('Falsy result returned from handler')
       return {
         status: 500,
         body: new Error('Handler did not return a result'),

packages/core/test/lib/Kopflos.test.ts

@@ -181,6 +181,42 @@ describe('lib/Kopflos', () => {
         // then
         expect(response.body).to.eq('C')
       })
+
+      it('guards against falsy handler result', async function () {
+        // given
+        const chainedHandler = (letter: string): Handler => () => {
+          return {
+            status: 200,
+            body: letter,
+          }
+        }
+        const kopflos = new Kopflos(config, {
+          dataset: this.rdf.dataset,
+          resourceShapeLookup: async () => [{
+            api: ex.api,
+            resourceShape: ex.FooShape,
+            subject: ex.foo,
+          }],
+          handlerLookup: () => [
+            chainedHandler('A'),
+            () => undefined as unknown as KopflosResponse,
+            chainedHandler('C'),
+          ],
+          resourceLoaderLookup: async () => () => rdf.dataset().toStream(),
+        })
+
+        // when
+        const response = await kopflos.handleRequest({
+          iri: ex.foo,
+          method: 'GET',
+          headers: {},
+          body: {} as Body,
+          query: {},
+        })
+
+        // then
+        expect(response.status).to.eq(500)
+      })
     })
 
     it('guards against falsy handler result', async function () {