feat: Add ConstantMetadataWriter.

src/index.ts

@@ -24,6 +24,7 @@ export * from './init/ServerInitializer';
 
 // LDP/HTTP/Metadata
 export * from './ldp/http/metadata/BasicMetadataExtractor';
+export * from './ldp/http/metadata/ConstantMetadataWriter';
 export * from './ldp/http/metadata/ContentTypeParser';
 export * from './ldp/http/metadata/LinkRelMetadataWriter';
 export * from './ldp/http/metadata/LinkTypeParser';

src/ldp/http/metadata/ConstantMetadataWriter.ts

@@ -0,0 +1,21 @@
+import type { HttpResponse } from '../../../server/HttpResponse';
+import { addHeader } from '../../../util/HeaderUtil';
+import { MetadataWriter } from './MetadataWriter';
+
+/**
+ * A {@link MetadataWriter} that takes a constant map of header names and values.
+ */
+export class ConstantMetadataWriter extends MetadataWriter {
+  private readonly headers: [string, string][];
+
+  public constructor(headers: Record<string, string>) {
+    super();
+    this.headers = Object.entries(headers);
+  }
+
+  public async handle({ response }: { response: HttpResponse }): Promise<void> {
+    for (const [ key, value ] of this.headers) {
+      addHeader(response, key, value);
+    }
+  }
+}

src/ldp/http/metadata/MappedMetadataWriter.ts

@@ -8,18 +8,18 @@ import { MetadataWriter } from './MetadataWriter';
  * The header value(s) will be the same as the corresponding object value(s).
  */
 export class MappedMetadataWriter extends MetadataWriter {
-  private readonly headerMap: Record<string, string>;
+  private readonly headerMap: [string, string][];
 
   public constructor(headerMap: Record<string, string>) {
     super();
-    this.headerMap = headerMap;
+    this.headerMap = Object.entries(headerMap);
   }
 
   public async handle(input: { response: HttpResponse; metadata: RepresentationMetadata }): Promise<void> {
-    for (const key of Object.keys(this.headerMap)) {
-      const values = input.metadata.getAll(key).map((term): string => term.value);
-      if (values.length > 0) {
-        addHeader(input.response, this.headerMap[key], values);
+    for (const [ predicate, header ] of this.headerMap) {
+      const terms = input.metadata.getAll(predicate);
+      if (terms.length > 0) {
+        addHeader(input.response, header, terms.map((term): string => term.value));
       }
     }
   }

test/unit/ldp/http/metadata/ConstantMetadataWriter.test.ts

@@ -0,0 +1,23 @@
+import { createResponse } from 'node-mocks-http';
+import { ConstantMetadataWriter } from '../../../../../src/ldp/http/metadata/ConstantMetadataWriter';
+
+describe('A ConstantMetadataWriter', (): void => {
+  const writer = new ConstantMetadataWriter({ 'custom-Header': 'X', other: 'Y' });
+
+  it('adds new headers.', async(): Promise<void> => {
+    const response = createResponse();
+
+    await expect(writer.handle({ response })).resolves.toBeUndefined();
+
+    expect(response.getHeaders()).toEqual({ 'custom-header': 'X', other: 'Y' });
+  });
+
+  it('extends existing headers.', async(): Promise<void> => {
+    const response = createResponse();
+    response.setHeader('Other', 'A');
+
+    await expect(writer.handle({ response })).resolves.toBeUndefined();
+
+    expect(response.getHeaders()).toEqual({ 'custom-header': 'X', other: [ 'A', 'Y' ]});
+  });
+});