chore: Add SPARQL endpoint logging.

src/storage/accessors/SparqlDataAccessor.ts

@@ -17,6 +17,7 @@ import {
 import type { Representation } from '../../ldp/representation/Representation';
 import { RepresentationMetadata } from '../../ldp/representation/RepresentationMetadata';
 import type { ResourceIdentifier } from '../../ldp/representation/ResourceIdentifier';
+import { getLoggerFor } from '../../logging/LogUtil';
 import { INTERNAL_QUADS } from '../../util/ContentTypes';
 import { ConflictHttpError } from '../../util/errors/ConflictHttpError';
 import { NotFoundHttpError } from '../../util/errors/NotFoundHttpError';
@@ -44,6 +45,7 @@ const { defaultGraph, namedNode, quad, variable } = DataFactory;
  * so those don't get overwritten.
  */
 export class SparqlDataAccessor implements DataAccessor {
+  protected readonly logger = getLoggerFor(this);
   private readonly endpoint: string;
   private readonly base: string;
   private readonly containerManager: ContainerManager;
@@ -298,7 +300,15 @@ export class SparqlDataAccessor implements DataAccessor {
    */
   private async sendSparqlConstruct(sparqlQuery: ConstructQuery): Promise<Readable> {
     const query = this.generator.stringify(sparqlQuery);
-    return await this.fetcher.fetchTriples(this.endpoint, query);
+    this.logger.info(`Sending SPARQL CONSTRUCT query to ${this.endpoint}: ${query}`);
+    try {
+      return await this.fetcher.fetchTriples(this.endpoint, query);
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        this.logger.error(`SPARQL endpoint ${this.endpoint} error: ${error.message}`);
+      }
+      throw error;
+    }
   }
 
   /**
@@ -307,6 +317,14 @@ export class SparqlDataAccessor implements DataAccessor {
    */
   private async sendSparqlUpdate(sparqlQuery: Update): Promise<void> {
     const query = this.generator.stringify(sparqlQuery);
-    return await this.fetcher.fetchUpdate(this.endpoint, query);
+    this.logger.info(`Sending SPARQL UPDATE query to ${this.endpoint}: ${query}`);
+    try {
+      return await this.fetcher.fetchUpdate(this.endpoint, query);
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        this.logger.error(`SPARQL endpoint ${this.endpoint} error: ${error.message}`);
+      }
+      throw error;
+    }
   }
 }

test/unit/storage/accessors/SparqlDataAccessor.test.ts

@@ -35,14 +35,25 @@ describe('A SparqlDataAccessor', (): void => {
   let fetchTriples: jest.Mock<Promise<Readable>>;
   let fetchUpdate: jest.Mock<Promise<void>>;
   let triples: Quad[];
+  let fetchError: any;
+  let updateError: any;
 
   beforeEach(async(): Promise<void> => {
     metadata = new RepresentationMetadata();
     triples = [ quad(namedNode('this'), namedNode('a'), namedNode('triple')) ];
 
-    // Makes it so the `SparqlEndpointFetcher` will always return the contents of the `bindings` array
+    // Makes it so the `SparqlEndpointFetcher` will always return the contents of the `triples` array
-    fetchTriples = jest.fn(async(): Promise<Readable> => streamifyArray(triples));
+    fetchTriples = jest.fn(async(): Promise<Readable> => {
-    fetchUpdate = jest.fn(async(): Promise<void> => undefined);
+      if (fetchError) {
+        throw fetchError;
+      }
+      return streamifyArray(triples);
+    });
+    fetchUpdate = jest.fn(async(): Promise<void> => {
+      if (updateError) {
+        throw updateError;
+      }
+    });
     (SparqlEndpointFetcher as any).mockImplementation((): any => ({
       fetchTriples,
       fetchUpdate,
@@ -128,8 +139,8 @@ describe('A SparqlDataAccessor', (): void => {
   });
 
   it('throws 404 if no metadata was found.', async(): Promise<void> => {
-    // Clear bindings array
+    // Clear triples array
-    triples.splice(0, triples.length);
+    triples = [];
     await expect(accessor.getMetadata({ path: 'http://identifier' })).rejects.toThrow(NotFoundHttpError);
 
     expect(fetchTriples).toHaveBeenCalledTimes(1);
@@ -205,4 +216,27 @@ describe('A SparqlDataAccessor', (): void => {
     await expect(accessor.writeDocument({ path: 'http://test.com/container/resource' }, data, metadata))
       .rejects.toThrow(new UnsupportedHttpError('Only triples in the default graph are supported.'));
   });
+
+  it('errors when the SPARQL endpoint fails during reading.', async(): Promise<void> => {
+    fetchError = 'error';
+    await expect(accessor.getMetadata({ path: 'http://identifier' })).rejects.toBe(fetchError);
+
+    fetchError = new Error();
+    await expect(accessor.getMetadata({ path: 'http://identifier' })).rejects.toThrow(fetchError);
+
+    fetchError = undefined;
+  });
+
+  it('errors when the SPARQL endpoint fails during writing.', async(): Promise<void> => {
+    const path = 'http://test.com/container/';
+    metadata = new RepresentationMetadata(path);
+
+    updateError = 'error';
+    await expect(accessor.writeContainer({ path }, metadata)).rejects.toBe(updateError);
+
+    updateError = new Error();
+    await expect(accessor.writeContainer({ path }, metadata)).rejects.toThrow(updateError);
+
+    updateError = undefined;
+  });
 });